#include <string.h>
#include <algorithm>

#include "FnvHash.h"

#include "log.h"

// FnvHash::FnvHash() {
long FnvHash::BASIC = 0xcbf29ce484222325L;
long FnvHash::PRIME = 0x100000001b3L;
// }

long FnvHash::fnv1a_64(string_ptr input)
{
  if (input->empty())
  {
    return 0;
  }

  long hash = BASIC;
  for (int i = 0; i < input->length(); ++i)
  {
    char c = input->at(i);
    hash ^= c;
    hash *= PRIME;
  }

  return hash;
}

// long FnvHash::fnv1a_64(std::stringbuf input) {
//         if (input == null) {
//             return 0;
//         }

//         long hash = BASIC;
//         for (int i = 0; i < input.length(); ++i) {
//             char c = input.charAt(i);
//             hash ^= c;
//             hash *= PRIME;
//         }

//         return hash;
//     }

long FnvHash::fnv1a_64(string_ptr input, int offset, int end)
{
  if (input->empty())
  {
    return 0;
  }

  if (input->length() < end)
  {
    end = input->length();
  }

  long hash = BASIC;
  for (int i = offset; i < end; ++i)
  {
    char c = input->at(i);
    hash ^= c;
    hash *= PRIME;
  }

  return hash;
}

long FnvHash::fnv1a_64(char *input, int offset, int end)
{
  if (input == NULL)
  {
    return 0;
  }

  if (strlen(input) < end)
  {
    end = strlen(input);
  }

  long hash = BASIC;
  for (int i = offset; i < end; ++i)
  {
    char c = input[i];
    hash ^= c;
    hash *= PRIME;
  }

  return hash;
}

long FnvHash::fnv1a_64(char *chars)
{
  if (chars == NULL)
  {
    return 0;
  }
  long hash = BASIC;
  for (int i = 0; i < strlen(chars); ++i)
  {
    char c = chars[i];
    hash ^= c;
    hash *= PRIME;
  }

  return hash;
}

/**
 * lower and normalized and fnv_1a_64
 *
 * @param name
 * @return
 */
long FnvHash::hashCode64(string_ptr name)
{
  if (name->empty())
  {
    return 0;
  }

  bool quote = false;

  int len = name->length();
  if (len > 2)
  {
    char c0 = name->at(0);
    char c1 = name->at(len - 1);
    if ((c0 == '`' && c1 == '`') ||
        (c0 == '"' && c1 == '"') ||
        (c0 == '\'' && c1 == '\'') ||
        (c0 == '[' && c1 == ']'))
    {
      quote = true;
    }
  }
  if (quote)
  {
    return FnvHash::hashCode64(name, 1, len - 1);
  }
  else
  {
    return FnvHash::hashCode64(name, 0, len);
  }
}

// long FnvHash::hashCode64(string_ptr name)
// {
//   return hashCode64(name);
// }
long FnvHash::fnv1a_64_lower(std::string key)
{
  return fnv1a_64_lower(make_string_ptr(key));
}

long FnvHash::fnv1a_64_lower(string_ptr key)
{
  long hashCode = BASIC;
  for (int i = 0; i < key->length(); ++i)
  {
    char ch = key->at(i);

    if (ch >= 'A' && ch <= 'Z')
    {
      ch = (char)(ch + 32);
    }

    hashCode ^= ch;
    hashCode *= PRIME;
  }

  // LOG_INFO << "key:" << key << ",hashCode:" << hashCode;
  return hashCode;
}
// long FnvHash::fnv1a_64_lower(string_ptr key)
// {
//   return fnv1a_64_lower(key);
// }
//  long FnvHash::fnv1a_64_lower(StringBuilder key) {
//         long hashCode = BASIC;
//         for (int i = 0; i < key.length(); ++i) {
//             char ch = key.charAt(i);

//             if (ch >= 'A' && ch <= 'Z') {
//                 ch = (char) (ch + 32);
//             }

//             hashCode ^= ch;
//             hashCode *= PRIME;
//         }

//         return hashCode;
//     }

long FnvHash::fnv1a_64_lower(long basic, string_ptr key)
{
  long hashCode = basic;
  for (int i = 0; i < key->length(); ++i)
  {
    char ch = key->at(i);

    if (ch >= 'A' && ch <= 'Z')
    {
      ch = (char)(ch + 32);
    }

    hashCode ^= ch;
    hashCode *= PRIME;
  }

  return hashCode;
}

long FnvHash::hashCode64(string_ptr key, int offset, int end)
{
  long hashCode = BASIC;
  for (int i = offset; i < end; ++i)
  {
    char ch = key->at(i);

    if (ch >= 'A' && ch <= 'Z')
    {
      ch = (char)(ch + 32);
    }

    hashCode ^= ch;
    hashCode *= PRIME;
  }

  return hashCode;
}

long FnvHash::hashCode64(long basic, string_ptr name)
{
  if (name->empty())
  {
    return basic;
  }

  bool quote = false;

  int len = name->length();
  if (len > 2)
  {
    char c0 = name->at(0);
    char c1 = name->at(len - 1);
    if ((c0 == '`' && c1 == '`') ||
        (c0 == '"' && c1 == '"') ||
        (c0 == '\'' && c1 == '\'') ||
        (c0 == '[' && c1 == ']'))
    {
      quote = true;
    }
  }
  if (quote)
  {
    int offset = 1;
    int end = len - 1;
    for (int i = end - 1; i >= 0; --i)
    {
      char ch = name->at(i);
      if (ch == ' ')
      {
        end--;
      }
      else
      {
        break;
      }
    }
    return FnvHash::hashCode64(basic, name, offset, end);
  }
  else
  {
    return FnvHash::hashCode64(basic, name, 0, len);
  }
}
// long FnvHash::hashCode64(long basic, string_ptr  name)
// {
//   return hashCode64(basic, name);
// }
long FnvHash::hashCode64(long basic, string_ptr key, int offset, int end)
{
  long hashCode = basic;
  for (int i = offset; i < end; ++i)
  {
    char ch = key->at(i);

    if (ch >= 'A' && ch <= 'Z')
    {
      ch = (char)(ch + 32);
    }

    hashCode ^= ch;
    hashCode *= PRIME;
  }

  return hashCode;
}

long FnvHash::fnv_32_lower(string_ptr key)
{
  long hashCode = 0x811c9dc5;
  for (int i = 0; i < key->length(); ++i)
  {
    char ch = key->at(i);
    if (ch == '_' || ch == '-')
    {
      continue;
    }

    if (ch >= 'A' && ch <= 'Z')
    {
      ch = (char)(ch + 32);
    }

    hashCode ^= ch;
    hashCode *= 0x01000193;
  }

  return hashCode;
}

std::shared_ptr<std::vector<long>> FnvHash::fnv1a_64_lower(std::shared_ptr<std::vector<string_ptr>> strings, bool sort_)
{
  std::shared_ptr<std::vector<long>> hashCodes = std::make_shared<std::vector<long>>();
  // LOG_INFO << "strings->size:" << strings->size();
  for (int i = 0; i < strings->size(); i++)
  {
    // LOG_INFO << "strings->at("<< i<<")" << strings->at(i) << ","<<FnvHash::fnv1a_64_lower(strings->at(i));
    hashCodes->push_back(FnvHash::fnv1a_64_lower(strings->at(i)));
  }

  if (sort_)
  {
    std::sort(hashCodes->begin(), hashCodes->end());
  }
  return hashCodes;
}

void FnvHash::fnv1a_64_lower(std::shared_ptr<std::vector<string_ptr>> strings, std::shared_ptr<std::vector<long>> out, bool sort_)
{
  // LOG_INFO << "strings->size:" << strings->size();
  for (int i = 0; i < strings->size(); i++)
  {
    // LOG_INFO << "strings->at("<< i<<")" << strings->at(i) << ","<<FnvHash::fnv1a_64_lower(strings->at(i));
    out->push_back(FnvHash::fnv1a_64_lower(strings->at(i)));
  }

  if (sort_)
  {
    std::sort(out->begin(), out->end());
  }
  return;
}
// long* FnvHash::fnv1a_64_lower(string_ptr  strings[], bool sort_)
// {
//   long hashCodes[sizeof(strings)];
//   for (int i = 0; i < sizeof(strings); i++)
//   {
//     hashCodes[i] = FnvHash::fnv1a_64_lower(strings[i]);
//   }
//   if (sort_)
//   {
//     std::sort(hashCodes, hashCodes + sizeof(strings));
//   }

//   return hashCodes;
// }

/**
 * normalized and lower and fnv1a_64_hash
 *
 * @param owner
 * @param name
 * @return
 */
long FnvHash::hashCode64(string_ptr owner, string_ptr name)
{
  long hashCode = BASIC;

  if (!owner->empty())
  {
    string_ptr item = owner;

    bool quote = false;

    int len = item->length();
    if (len > 2)
    {
      char c0 = item->at(0);
      char c1 = item->at(len - 1);
      if ((c0 == '`' && c1 == '`') ||
          (c0 == '"' && c1 == '"') ||
          (c0 == '\'' && c1 == '\'') ||
          (c0 == '[' && c1 == ']'))
      {
        quote = true;
      }
    }

    int start = quote ? 1 : 0;
    int end = quote ? len - 1 : len;
    for (int j = start; j < end; ++j)
    {
      char ch = item->at(j);

      if (ch >= 'A' && ch <= 'Z')
      {
        ch = (char)(ch + 32);
      }

      hashCode ^= ch;
      hashCode *= PRIME;
    }

    hashCode ^= '.';
    hashCode *= PRIME;
  }

  if (!name->empty())
  {
    string_ptr item = name;

    bool quote = false;

    int len = item->length();
    if (len > 2)
    {
      char c0 = item->at(0);
      char c1 = item->at(len - 1);
      if ((c0 == '`' && c1 == '`') ||
          (c0 == '"' && c1 == '"') ||
          (c0 == '\'' && c1 == '\'') ||
          (c0 == '[' && c1 == ']'))
      {
        quote = true;
      }
    }

    int start = quote ? 1 : 0;
    int end = quote ? len - 1 : len;
    for (int j = start; j < end; ++j)
    {
      char ch = item->at(j);

      if (ch >= 'A' && ch <= 'Z')
      {
        ch = (char)(ch + 32);
      }

      hashCode ^= ch;
      hashCode *= PRIME;
    }
  }

  return hashCode;
}

long FnvHash::Constants::HIGH_PRIORITY = FnvHash::fnv1a_64_lower(make_string_ptr("HIGH_PRIORITY"));
long FnvHash::Constants::DISTINCTROW = FnvHash::fnv1a_64_lower(make_string_ptr("DISTINCTROW"));
long FnvHash::Constants::STRAIGHT = FnvHash::fnv1a_64_lower(make_string_ptr("STRAIGHT"));
long FnvHash::Constants::STRAIGHT_JOIN = FnvHash::fnv1a_64_lower(make_string_ptr("STRAIGHT_JOIN"));
long FnvHash::Constants::SQL_SMALL_RESULT = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_SMALL_RESULT"));
long FnvHash::Constants::SQL_BIG_RESULT = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_BIG_RESULT"));
long FnvHash::Constants::SQL_BUFFER_RESULT = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_BUFFER_RESULT"));
long FnvHash::Constants::CACHE = FnvHash::fnv1a_64_lower(make_string_ptr("CACHE"));
long FnvHash::Constants::SQL_CACHE = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_CACHE"));
long FnvHash::Constants::SQL_NO_CACHE = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_NO_CACHE"));
long FnvHash::Constants::SQL_CALC_FOUND_ROWS = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_CALC_FOUND_ROWS"));
long FnvHash::Constants::TOP = FnvHash::fnv1a_64_lower(make_string_ptr("TOP"));
long FnvHash::Constants::OUTFILE = FnvHash::fnv1a_64_lower(make_string_ptr("OUTFILE"));
long FnvHash::Constants::SETS = FnvHash::fnv1a_64_lower(make_string_ptr("SETS"));
long FnvHash::Constants::REGEXP = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP"));
long FnvHash::Constants::RLIKE = FnvHash::fnv1a_64_lower(make_string_ptr("RLIKE"));
long FnvHash::Constants::USING = FnvHash::fnv1a_64_lower(make_string_ptr("USING"));
long FnvHash::Constants::MATCHED = FnvHash::fnv1a_64_lower(make_string_ptr("MATCHED"));
long FnvHash::Constants::IGNORE = FnvHash::fnv1a_64_lower(make_string_ptr("IGNORE"));
long FnvHash::Constants::FORCE = FnvHash::fnv1a_64_lower(make_string_ptr("FORCE"));
long FnvHash::Constants::CROSS = FnvHash::fnv1a_64_lower(make_string_ptr("CROSS"));
long FnvHash::Constants::NATURAL = FnvHash::fnv1a_64_lower(make_string_ptr("NATURAL"));
long FnvHash::Constants::APPLY = FnvHash::fnv1a_64_lower(make_string_ptr("APPLY"));
long FnvHash::Constants::CONNECT = FnvHash::fnv1a_64_lower(make_string_ptr("CONNECT"));
long FnvHash::Constants::START = FnvHash::fnv1a_64_lower(make_string_ptr("START"));
long FnvHash::Constants::BTREE = FnvHash::fnv1a_64_lower(make_string_ptr("BTREE"));
long FnvHash::Constants::HASH = FnvHash::fnv1a_64_lower(make_string_ptr("HASH"));
long FnvHash::Constants::DUPLICATE = FnvHash::fnv1a_64_lower(make_string_ptr("DUPLICATE"));
long FnvHash::Constants::LIST = FnvHash::fnv1a_64_lower(make_string_ptr("LIST"));
long FnvHash::Constants::NO_WAIT = FnvHash::fnv1a_64_lower(make_string_ptr("NO_WAIT"));
long FnvHash::Constants::WAIT = FnvHash::fnv1a_64_lower(make_string_ptr("WAIT"));
long FnvHash::Constants::NOWAIT = FnvHash::fnv1a_64_lower(make_string_ptr("NOWAIT"));
long FnvHash::Constants::ERRORS = FnvHash::fnv1a_64_lower(make_string_ptr("ERRORS"));
long FnvHash::Constants::VALUE = FnvHash::fnv1a_64_lower(make_string_ptr("VALUE"));
long FnvHash::Constants::OBJECT = FnvHash::fnv1a_64_lower(make_string_ptr("OBJECT"));
long FnvHash::Constants::NEXT = FnvHash::fnv1a_64_lower(make_string_ptr("NEXT"));
long FnvHash::Constants::NEXTVAL = FnvHash::fnv1a_64_lower(make_string_ptr("NEXTVAL"));
long FnvHash::Constants::CURRVAL = FnvHash::fnv1a_64_lower(make_string_ptr("CURRVAL"));
long FnvHash::Constants::PREVVAL = FnvHash::fnv1a_64_lower(make_string_ptr("PREVVAL"));
long FnvHash::Constants::PREVIOUS = FnvHash::fnv1a_64_lower(make_string_ptr("PREVIOUS"));
long FnvHash::Constants::LOW_PRIORITY = FnvHash::fnv1a_64_lower(make_string_ptr("LOW_PRIORITY"));
long FnvHash::Constants::COMMIT_ON_SUCCESS = FnvHash::fnv1a_64_lower(make_string_ptr("COMMIT_ON_SUCCESS"));
long FnvHash::Constants::ROLLBACK_ON_FAIL = FnvHash::fnv1a_64_lower(make_string_ptr("ROLLBACK_ON_FAIL"));
long FnvHash::Constants::QUEUE_ON_PK = FnvHash::fnv1a_64_lower(make_string_ptr("QUEUE_ON_PK"));
long FnvHash::Constants::TARGET_AFFECT_ROW = FnvHash::fnv1a_64_lower(make_string_ptr("TARGET_AFFECT_ROW"));
long FnvHash::Constants::COLLATE = FnvHash::fnv1a_64_lower(make_string_ptr("COLLATE"));
long FnvHash::Constants::BOOLEAN = FnvHash::fnv1a_64_lower(make_string_ptr("BOOLEAN"));
long FnvHash::Constants::SMALLINT = FnvHash::fnv1a_64_lower(make_string_ptr("SMALLINT"));
long FnvHash::Constants::SHORT = FnvHash::fnv1a_64_lower(make_string_ptr("SHORT"));
long FnvHash::Constants::TINY = FnvHash::fnv1a_64_lower(make_string_ptr("TINY"));
long FnvHash::Constants::TINYINT = FnvHash::fnv1a_64_lower(make_string_ptr("TINYINT"));
long FnvHash::Constants::CHARSET = FnvHash::fnv1a_64_lower(make_string_ptr("CHARSET"));
long FnvHash::Constants::SEMI = FnvHash::fnv1a_64_lower(make_string_ptr("SEMI"));
long FnvHash::Constants::ANTI = FnvHash::fnv1a_64_lower(make_string_ptr("ANTI"));
long FnvHash::Constants::PRIOR = FnvHash::fnv1a_64_lower(make_string_ptr("PRIOR"));
long FnvHash::Constants::NOCYCLE = FnvHash::fnv1a_64_lower(make_string_ptr("NOCYCLE"));
long FnvHash::Constants::CYCLE = FnvHash::fnv1a_64_lower(make_string_ptr("CYCLE"));
long FnvHash::Constants::CONNECT_BY_ROOT = FnvHash::fnv1a_64_lower(make_string_ptr("CONNECT_BY_ROOT"));

long FnvHash::Constants::DATE = FnvHash::fnv1a_64_lower(make_string_ptr("DATE"));
long FnvHash::Constants::GSON = FnvHash::fnv1a_64_lower(make_string_ptr("GSON"));
long FnvHash::Constants::NEW = FnvHash::fnv1a_64_lower(make_string_ptr("NEW"));
long FnvHash::Constants::NEWDATE = FnvHash::fnv1a_64_lower(make_string_ptr("NEWDATE"));
long FnvHash::Constants::DATETIME = FnvHash::fnv1a_64_lower(make_string_ptr("DATETIME"));
long FnvHash::Constants::TIME = FnvHash::fnv1a_64_lower(make_string_ptr("TIME"));
long FnvHash::Constants::ZONE = FnvHash::fnv1a_64_lower(make_string_ptr("ZONE"));
long FnvHash::Constants::JSON = FnvHash::fnv1a_64_lower(make_string_ptr("JSON"));
long FnvHash::Constants::TIMESTAMP = FnvHash::fnv1a_64_lower(make_string_ptr("TIMESTAMP"));
long FnvHash::Constants::TIMESTAMPTZ = FnvHash::fnv1a_64_lower(make_string_ptr("TIMESTAMPTZ"));
long FnvHash::Constants::CLOB = FnvHash::fnv1a_64_lower(make_string_ptr("CLOB"));
long FnvHash::Constants::NCLOB = FnvHash::fnv1a_64_lower(make_string_ptr("NCLOB"));
long FnvHash::Constants::TINYBLOB = FnvHash::fnv1a_64_lower(make_string_ptr("TINYBLOB"));
long FnvHash::Constants::BLOB = FnvHash::fnv1a_64_lower(make_string_ptr("BLOB"));
long FnvHash::Constants::XMLTYPE = FnvHash::fnv1a_64_lower(make_string_ptr("XMLTYPE"));
long FnvHash::Constants::BFILE = FnvHash::fnv1a_64_lower(make_string_ptr("BFILE"));
long FnvHash::Constants::UROWID = FnvHash::fnv1a_64_lower(make_string_ptr("UROWID"));
long FnvHash::Constants::ROWID = FnvHash::fnv1a_64_lower(make_string_ptr("ROWID"));
long FnvHash::Constants::REF = FnvHash::fnv1a_64_lower(make_string_ptr("REF"));
long FnvHash::Constants::INTEGER = FnvHash::fnv1a_64_lower(make_string_ptr("INTEGER"));
long FnvHash::Constants::INT = FnvHash::fnv1a_64_lower(make_string_ptr("INT"));
long FnvHash::Constants::INT24 = FnvHash::fnv1a_64_lower(make_string_ptr("INT24"));
long FnvHash::Constants::BINARY_FLOAT = FnvHash::fnv1a_64_lower(make_string_ptr("BINARY_FLOAT"));
long FnvHash::Constants::BINARY_DOUBLE = FnvHash::fnv1a_64_lower(make_string_ptr("BINARY_DOUBLE"));
long FnvHash::Constants::FLOAT = FnvHash::fnv1a_64_lower(make_string_ptr("FLOAT"));
long FnvHash::Constants::REAL = FnvHash::fnv1a_64_lower(make_string_ptr("REAL"));
long FnvHash::Constants::NUMBER = FnvHash::fnv1a_64_lower(make_string_ptr("NUMBER"));
long FnvHash::Constants::NUMERIC = FnvHash::fnv1a_64_lower(make_string_ptr("NUMERIC"));
long FnvHash::Constants::DEC = FnvHash::fnv1a_64_lower(make_string_ptr("DEC"));
long FnvHash::Constants::DECIMAL = FnvHash::fnv1a_64_lower(make_string_ptr("DECIMAL"));

long FnvHash::Constants::CURRENT = FnvHash::fnv1a_64_lower(make_string_ptr("CURRENT"));
long FnvHash::Constants::COUNT = FnvHash::fnv1a_64_lower(make_string_ptr("COUNT"));
long FnvHash::Constants::ROW_NUMBER = FnvHash::fnv1a_64_lower(make_string_ptr("ROW_NUMBER"));
long FnvHash::Constants::FIRST_VALUE = FnvHash::fnv1a_64_lower(make_string_ptr("FIRST_VALUE"));
long FnvHash::Constants::LAST_VALUE = FnvHash::fnv1a_64_lower(make_string_ptr("LAST_VALUE"));
long FnvHash::Constants::WM_CONCAT = FnvHash::fnv1a_64_lower(make_string_ptr("WM_CONCAT"));
long FnvHash::Constants::AVG = FnvHash::fnv1a_64_lower(make_string_ptr("AVG"));
long FnvHash::Constants::MAX = FnvHash::fnv1a_64_lower(make_string_ptr("MAX"));
long FnvHash::Constants::MIN = FnvHash::fnv1a_64_lower(make_string_ptr("MIN"));
long FnvHash::Constants::STDDEV = FnvHash::fnv1a_64_lower(make_string_ptr("STDDEV"));
long FnvHash::Constants::RANK = FnvHash::fnv1a_64_lower(make_string_ptr("RANK"));
long FnvHash::Constants::SUM = FnvHash::fnv1a_64_lower(make_string_ptr("SUM"));
long FnvHash::Constants::ARBITRARY = FnvHash::fnv1a_64_lower(make_string_ptr("ARBITRARY"));
long FnvHash::Constants::GROUP_CONCAT = FnvHash::fnv1a_64_lower(make_string_ptr("GROUP_CONCAT"));
long FnvHash::Constants::CONVERT_TZ = FnvHash::fnv1a_64_lower(make_string_ptr("CONVERT_TZ"));
long FnvHash::Constants::DEDUPLICATION = FnvHash::fnv1a_64_lower(make_string_ptr("DEDUPLICATION"));
long FnvHash::Constants::CONVERT = FnvHash::fnv1a_64_lower(make_string_ptr("CONVERT"));
long FnvHash::Constants::CHAR = FnvHash::fnv1a_64_lower(make_string_ptr("CHAR"));
long FnvHash::Constants::ENUM = FnvHash::fnv1a_64_lower(make_string_ptr("ENUM"));
long FnvHash::Constants::STRING = FnvHash::fnv1a_64_lower(make_string_ptr("STRING"));
long FnvHash::Constants::VARCHAR = FnvHash::fnv1a_64_lower(make_string_ptr("VARCHAR"));
long FnvHash::Constants::VARCHAR2 = FnvHash::fnv1a_64_lower(make_string_ptr("VARCHAR2"));
long FnvHash::Constants::NCHAR = FnvHash::fnv1a_64_lower(make_string_ptr("NCHAR"));
long FnvHash::Constants::NVARCHAR = FnvHash::fnv1a_64_lower(make_string_ptr("NVARCHAR"));
long FnvHash::Constants::NVARCHAR2 = FnvHash::fnv1a_64_lower(make_string_ptr("NVARCHAR2"));
long FnvHash::Constants::NCHAR_VARYING = FnvHash::fnv1a_64_lower(make_string_ptr("nchar varying"));
long FnvHash::Constants::VARBINARY = FnvHash::fnv1a_64_lower(make_string_ptr("VARBINARY"));
long FnvHash::Constants::TINYTEXT = FnvHash::fnv1a_64_lower(make_string_ptr("TINYTEXT"));
long FnvHash::Constants::TEXT = FnvHash::fnv1a_64_lower(make_string_ptr("TEXT"));
long FnvHash::Constants::MEDIUMTEXT = FnvHash::fnv1a_64_lower(make_string_ptr("MEDIUMTEXT"));
long FnvHash::Constants::LONGTEXT = FnvHash::fnv1a_64_lower(make_string_ptr("LONGTEXT"));
long FnvHash::Constants::TRIM = FnvHash::fnv1a_64_lower(make_string_ptr("TRIM"));
long FnvHash::Constants::LEADING = FnvHash::fnv1a_64_lower(make_string_ptr("LEADING"));
long FnvHash::Constants::BOTH = FnvHash::fnv1a_64_lower(make_string_ptr("BOTH"));
long FnvHash::Constants::TRAILING = FnvHash::fnv1a_64_lower(make_string_ptr("TRAILING"));
long FnvHash::Constants::MOD = FnvHash::fnv1a_64_lower(make_string_ptr("MOD"));
long FnvHash::Constants::MATCH = FnvHash::fnv1a_64_lower(make_string_ptr("MATCH"));
long FnvHash::Constants::AGAINST = FnvHash::fnv1a_64_lower(make_string_ptr("AGAINST"));
long FnvHash::Constants::EXTRACT = FnvHash::fnv1a_64_lower(make_string_ptr("EXTRACT"));
long FnvHash::Constants::POLYGON = FnvHash::fnv1a_64_lower(make_string_ptr("POLYGON"));
long FnvHash::Constants::CIRCLE = FnvHash::fnv1a_64_lower(make_string_ptr("CIRCLE"));
long FnvHash::Constants::LSEG = FnvHash::fnv1a_64_lower(make_string_ptr("LSEG"));
long FnvHash::Constants::POINT = FnvHash::fnv1a_64_lower(make_string_ptr("POINT"));
long FnvHash::Constants::BOX = FnvHash::fnv1a_64_lower(make_string_ptr("BOX"));
long FnvHash::Constants::MACADDR = FnvHash::fnv1a_64_lower(make_string_ptr("MACADDR"));
long FnvHash::Constants::INET = FnvHash::fnv1a_64_lower(make_string_ptr("INET"));
long FnvHash::Constants::CIDR = FnvHash::fnv1a_64_lower(make_string_ptr("CIDR"));
long FnvHash::Constants::POSITION = FnvHash::fnv1a_64_lower(make_string_ptr("POSITION"));
long FnvHash::Constants::DUAL = FnvHash::fnv1a_64_lower(make_string_ptr("DUAL"));
long FnvHash::Constants::LEVEL = FnvHash::fnv1a_64_lower(make_string_ptr("LEVEL"));
long FnvHash::Constants::CONNECT_BY_ISCYCLE = FnvHash::fnv1a_64_lower(make_string_ptr("CONNECT_BY_ISCYCLE"));
long FnvHash::Constants::CURRENT_TIMESTAMP = FnvHash::fnv1a_64_lower(make_string_ptr("CURRENT_TIMESTAMP"));
long FnvHash::Constants::LOCALTIMESTAMP = FnvHash::fnv1a_64_lower(make_string_ptr("LOCALTIMESTAMP"));
long FnvHash::Constants::LOCALTIME = FnvHash::fnv1a_64_lower(make_string_ptr("LOCALTIME"));
long FnvHash::Constants::SESSIONTIMEZONE = FnvHash::fnv1a_64_lower(make_string_ptr("SESSIONTIMEZONE"));
long FnvHash::Constants::DBTIMEZONE = FnvHash::fnv1a_64_lower(make_string_ptr("DBTIMEZONE"));
long FnvHash::Constants::CURRENT_DATE = FnvHash::fnv1a_64_lower(make_string_ptr("CURRENT_DATE"));
long FnvHash::Constants::CURRENT_TIME = FnvHash::fnv1a_64_lower(make_string_ptr("CURRENT_TIME"));
long FnvHash::Constants::CURTIME = FnvHash::fnv1a_64_lower(make_string_ptr("CURTIME"));
long FnvHash::Constants::CURRENT_USER = FnvHash::fnv1a_64_lower(make_string_ptr("CURRENT_USER"));
long FnvHash::Constants::XFALSE = FnvHash::fnv1a_64_lower(make_string_ptr("FALSE"));
long FnvHash::Constants::XTRUE = FnvHash::fnv1a_64_lower(make_string_ptr("TRUE"));
long FnvHash::Constants::LESS = FnvHash::fnv1a_64_lower(make_string_ptr("LESS"));
long FnvHash::Constants::MAXVALUE = FnvHash::fnv1a_64_lower(make_string_ptr("MAXVALUE"));
long FnvHash::Constants::OFFSET = FnvHash::fnv1a_64_lower(make_string_ptr("OFFSET"));
long FnvHash::Constants::LIMIT = FnvHash::fnv1a_64_lower(make_string_ptr("LIMIT"));
long FnvHash::Constants::RAW = FnvHash::fnv1a_64_lower(make_string_ptr("RAW"));
long FnvHash::Constants::LONG_RAW = FnvHash::fnv1a_64_lower(make_string_ptr("LONG RAW"));
long FnvHash::Constants::LONG = FnvHash::fnv1a_64_lower(make_string_ptr("LONG"));
long FnvHash::Constants::BYTE = FnvHash::fnv1a_64_lower(make_string_ptr("BYTE"));
long FnvHash::Constants::ROWNUM = FnvHash::fnv1a_64_lower(make_string_ptr("ROWNUM"));
long FnvHash::Constants::SYSDATE = FnvHash::fnv1a_64_lower(make_string_ptr("SYSDATE"));
long FnvHash::Constants::NOW = FnvHash::fnv1a_64_lower(make_string_ptr("NOW"));
long FnvHash::Constants::ADDTIME = FnvHash::fnv1a_64_lower(make_string_ptr("ADDTIME"));
long FnvHash::Constants::SUBTIME = FnvHash::fnv1a_64_lower(make_string_ptr("SUBTIME"));
long FnvHash::Constants::TIMEDIFF = FnvHash::fnv1a_64_lower(make_string_ptr("TIMEDIFF"));
long FnvHash::Constants::SQLCODE = FnvHash::fnv1a_64_lower(make_string_ptr("SQLCODE"));
long FnvHash::Constants::PRECISION = FnvHash::fnv1a_64_lower(make_string_ptr("PRECISION"));
long FnvHash::Constants::DOUBLE = FnvHash::fnv1a_64_lower(make_string_ptr("DOUBLE"));
long FnvHash::Constants::DOUBLE_PRECISION = FnvHash::fnv1a_64_lower(make_string_ptr("DOUBLE PRECISION"));
long FnvHash::Constants::WITHOUT = FnvHash::fnv1a_64_lower(make_string_ptr("WITHOUT"));
long FnvHash::Constants::BITAND = FnvHash::fnv1a_64_lower(make_string_ptr("BITAND"));

long FnvHash::Constants::DEFINER = FnvHash::fnv1a_64_lower(make_string_ptr("DEFINER"));
long FnvHash::Constants::EVENT = FnvHash::fnv1a_64_lower(make_string_ptr("EVENT"));
long FnvHash::Constants::RESOURCE = FnvHash::fnv1a_64_lower(make_string_ptr("RESOURCE"));
long FnvHash::Constants::RESOURCES = FnvHash::fnv1a_64_lower(make_string_ptr("RESOURCES"));
long FnvHash::Constants::FILE = FnvHash::fnv1a_64_lower(make_string_ptr("FILE"));
long FnvHash::Constants::JAR = FnvHash::fnv1a_64_lower(make_string_ptr("JAR"));
long FnvHash::Constants::PY = FnvHash::fnv1a_64_lower(make_string_ptr("PY"));
long FnvHash::Constants::ARCHIVE = FnvHash::fnv1a_64_lower(make_string_ptr("archive"));
long FnvHash::Constants::DETERMINISTIC = FnvHash::fnv1a_64_lower(make_string_ptr("DETERMINISTIC"));
long FnvHash::Constants::CONTAINS = FnvHash::fnv1a_64_lower(make_string_ptr("CONTAINS"));
long FnvHash::Constants::SQL = FnvHash::fnv1a_64_lower(make_string_ptr("SQL"));
long FnvHash::Constants::CALL = FnvHash::fnv1a_64_lower(make_string_ptr("CALL"));
long FnvHash::Constants::CHARACTER = FnvHash::fnv1a_64_lower(make_string_ptr("CHARACTER"));
long FnvHash::Constants::UNNEST = FnvHash::fnv1a_64_lower(make_string_ptr("UNNEST"));

long FnvHash::Constants::VALIDATE = FnvHash::fnv1a_64_lower(make_string_ptr("VALIDATE"));
long FnvHash::Constants::NOVALIDATE = FnvHash::fnv1a_64_lower(make_string_ptr("NOVALIDATE"));
long FnvHash::Constants::SIMILAR = FnvHash::fnv1a_64_lower(make_string_ptr("SIMILAR"));
long FnvHash::Constants::CASCADE = FnvHash::fnv1a_64_lower(make_string_ptr("CASCADE"));
long FnvHash::Constants::RELY = FnvHash::fnv1a_64_lower(make_string_ptr("RELY"));
long FnvHash::Constants::NORELY = FnvHash::fnv1a_64_lower(make_string_ptr("NORELY"));
long FnvHash::Constants::ROW = FnvHash::fnv1a_64_lower(make_string_ptr("ROW"));
long FnvHash::Constants::ROWS = FnvHash::fnv1a_64_lower(make_string_ptr("ROWS"));
long FnvHash::Constants::RANGE = FnvHash::fnv1a_64_lower(make_string_ptr("RANGE"));
long FnvHash::Constants::PRECEDING = FnvHash::fnv1a_64_lower(make_string_ptr("PRECEDING"));
long FnvHash::Constants::FOLLOWING = FnvHash::fnv1a_64_lower(make_string_ptr("FOLLOWING"));
long FnvHash::Constants::UNBOUNDED = FnvHash::fnv1a_64_lower(make_string_ptr("UNBOUNDED"));
long FnvHash::Constants::SIBLINGS = FnvHash::fnv1a_64_lower(make_string_ptr("SIBLINGS"));
long FnvHash::Constants::RESPECT = FnvHash::fnv1a_64_lower(make_string_ptr("RESPECT"));
long FnvHash::Constants::NULLS = FnvHash::fnv1a_64_lower(make_string_ptr("NULLS"));
long FnvHash::Constants::FIRST = FnvHash::fnv1a_64_lower(make_string_ptr("FIRST"));
long FnvHash::Constants::LAST = FnvHash::fnv1a_64_lower(make_string_ptr("LAST"));
long FnvHash::Constants::AUTO_INCREMENT = FnvHash::fnv1a_64_lower(make_string_ptr("AUTO_INCREMENT"));
long FnvHash::Constants::STORAGE = FnvHash::fnv1a_64_lower(make_string_ptr("STORAGE"));
long FnvHash::Constants::STORED = FnvHash::fnv1a_64_lower(make_string_ptr("STORED"));
long FnvHash::Constants::VIRTUAL = FnvHash::fnv1a_64_lower(make_string_ptr("VIRTUAL"));
long FnvHash::Constants::SIGNED = FnvHash::fnv1a_64_lower(make_string_ptr("SIGNED"));
long FnvHash::Constants::UNSIGNED = FnvHash::fnv1a_64_lower(make_string_ptr("UNSIGNED"));
long FnvHash::Constants::ZEROFILL = FnvHash::fnv1a_64_lower(make_string_ptr("ZEROFILL"));
long FnvHash::Constants::GLOBAL = FnvHash::fnv1a_64_lower(make_string_ptr("GLOBAL"));
long FnvHash::Constants::LOCAL = FnvHash::fnv1a_64_lower(make_string_ptr("LOCAL"));
long FnvHash::Constants::TEMPORARY = FnvHash::fnv1a_64_lower(make_string_ptr("TEMPORARY"));
long FnvHash::Constants::NONCLUSTERED = FnvHash::fnv1a_64_lower(make_string_ptr("NONCLUSTERED"));
long FnvHash::Constants::SESSION = FnvHash::fnv1a_64_lower(make_string_ptr("SESSION"));
long FnvHash::Constants::NAMES = FnvHash::fnv1a_64_lower(make_string_ptr("NAMES"));
long FnvHash::Constants::PARTIAL = FnvHash::fnv1a_64_lower(make_string_ptr("PARTIAL"));
long FnvHash::Constants::SIMPLE = FnvHash::fnv1a_64_lower(make_string_ptr("SIMPLE"));
long FnvHash::Constants::RESTRICT = FnvHash::fnv1a_64_lower(make_string_ptr("RESTRICT"));
long FnvHash::Constants::ON = FnvHash::fnv1a_64_lower(make_string_ptr("ON"));
long FnvHash::Constants::ACTION = FnvHash::fnv1a_64_lower(make_string_ptr("ACTION"));
long FnvHash::Constants::SEPARATOR = FnvHash::fnv1a_64_lower(make_string_ptr("SEPARATOR"));
long FnvHash::Constants::DATA = FnvHash::fnv1a_64_lower(make_string_ptr("DATA"));
long FnvHash::Constants::MIGRATE = FnvHash::fnv1a_64_lower(make_string_ptr("MIGRATE"));
long FnvHash::Constants::MAX_ROWS = FnvHash::fnv1a_64_lower(make_string_ptr("MAX_ROWS"));
long FnvHash::Constants::MIN_ROWS = FnvHash::fnv1a_64_lower(make_string_ptr("MIN_ROWS"));
long FnvHash::Constants::PACK_KEYS = FnvHash::fnv1a_64_lower(make_string_ptr("PACK_KEYS"));
long FnvHash::Constants::ENGINE = FnvHash::fnv1a_64_lower(make_string_ptr("ENGINE"));
long FnvHash::Constants::SKIP = FnvHash::fnv1a_64_lower(make_string_ptr("SKIP"));
long FnvHash::Constants::RECURSIVE = FnvHash::fnv1a_64_lower(make_string_ptr("RECURSIVE"));
long FnvHash::Constants::ROLLUP = FnvHash::fnv1a_64_lower(make_string_ptr("ROLLUP"));
long FnvHash::Constants::CUBE = FnvHash::fnv1a_64_lower(make_string_ptr("CUBE"));

long FnvHash::Constants::YEAR = FnvHash::fnv1a_64_lower(make_string_ptr("YEAR"));
long FnvHash::Constants::QUARTER = FnvHash::fnv1a_64_lower(make_string_ptr("QUARTER"));
long FnvHash::Constants::MONTH = FnvHash::fnv1a_64_lower(make_string_ptr("MONTH"));
long FnvHash::Constants::WEEK = FnvHash::fnv1a_64_lower(make_string_ptr("WEEK"));
long FnvHash::Constants::WEEKDAY = FnvHash::fnv1a_64_lower(make_string_ptr("WEEKDAY"));
long FnvHash::Constants::WEEKOFYEAR = FnvHash::fnv1a_64_lower(make_string_ptr("WEEKOFYEAR"));
long FnvHash::Constants::YEARWEEK = FnvHash::fnv1a_64_lower(make_string_ptr("YEARWEEK"));
long FnvHash::Constants::YEAR_OF_WEEK = FnvHash::fnv1a_64_lower(make_string_ptr("YEAR_OF_WEEK"));
long FnvHash::Constants::YOW = FnvHash::fnv1a_64_lower(make_string_ptr("YOW"));
long FnvHash::Constants::YEARMONTH = FnvHash::fnv1a_64_lower(make_string_ptr("YEARMONTH"));
long FnvHash::Constants::TO_TIMESTAMP = FnvHash::fnv1a_64_lower(make_string_ptr("TO_TIMESTAMP"));
long FnvHash::Constants::DAY = FnvHash::fnv1a_64_lower(make_string_ptr("DAY"));
long FnvHash::Constants::DAYOFMONTH = FnvHash::fnv1a_64_lower(make_string_ptr("DAYOFMONTH"));
long FnvHash::Constants::DAYOFWEEK = FnvHash::fnv1a_64_lower(make_string_ptr("DAYOFWEEK"));
long FnvHash::Constants::DATE_TRUNC = FnvHash::fnv1a_64_lower(make_string_ptr("DATE_TRUNC"));
long FnvHash::Constants::DAYOFYEAR = FnvHash::fnv1a_64_lower(make_string_ptr("DAYOFYEAR"));
long FnvHash::Constants::MONTH_BETWEEN = FnvHash::fnv1a_64_lower(make_string_ptr("MONTH_BETWEEN"));
long FnvHash::Constants::TIMESTAMPADD = FnvHash::fnv1a_64_lower(make_string_ptr("TIMESTAMPADD"));
long FnvHash::Constants::HOUR = FnvHash::fnv1a_64_lower(make_string_ptr("HOUR"));
long FnvHash::Constants::MINUTE = FnvHash::fnv1a_64_lower(make_string_ptr("MINUTE"));
long FnvHash::Constants::SECOND = FnvHash::fnv1a_64_lower(make_string_ptr("SECOND"));
long FnvHash::Constants::MICROSECOND = FnvHash::fnv1a_64_lower(make_string_ptr("MICROSECOND"));
long FnvHash::Constants::CURDATE = FnvHash::fnv1a_64_lower(make_string_ptr("CURDATE"));
long FnvHash::Constants::CUR_DATE = FnvHash::fnv1a_64_lower(make_string_ptr("CUR_DATE"));
long FnvHash::Constants::DATE_DIFF = FnvHash::fnv1a_64_lower(make_string_ptr("DATE_DIFF"));

long FnvHash::Constants::SECONDS = FnvHash::fnv1a_64_lower(make_string_ptr("SECONDS"));
long FnvHash::Constants::MINUTES = FnvHash::fnv1a_64_lower(make_string_ptr("MINUTES"));
long FnvHash::Constants::HOURS = FnvHash::fnv1a_64_lower(make_string_ptr("HOURS"));
long FnvHash::Constants::DAYS = FnvHash::fnv1a_64_lower(make_string_ptr("DAYS"));
long FnvHash::Constants::MONTHS = FnvHash::fnv1a_64_lower(make_string_ptr("MONTHS"));
long FnvHash::Constants::YEARS = FnvHash::fnv1a_64_lower(make_string_ptr("YEARS"));

long FnvHash::Constants::BEFORE = FnvHash::fnv1a_64_lower(make_string_ptr("BEFORE"));
long FnvHash::Constants::AFTER = FnvHash::fnv1a_64_lower(make_string_ptr("AFTER"));
long FnvHash::Constants::INSTEAD = FnvHash::fnv1a_64_lower(make_string_ptr("INSTEAD"));

long FnvHash::Constants::DEFERRABLE = FnvHash::fnv1a_64_lower(make_string_ptr("DEFERRABLE"));
long FnvHash::Constants::AS = FnvHash::fnv1a_64_lower(make_string_ptr("AS"));
long FnvHash::Constants::DELAYED = FnvHash::fnv1a_64_lower(make_string_ptr("DELAYED"));
long FnvHash::Constants::GO = FnvHash::fnv1a_64_lower(make_string_ptr("GO"));
long FnvHash::Constants::WAITFOR = FnvHash::fnv1a_64_lower(make_string_ptr("WAITFOR"));
long FnvHash::Constants::EXEC = FnvHash::fnv1a_64_lower(make_string_ptr("EXEC"));
long FnvHash::Constants::EXECUTE = FnvHash::fnv1a_64_lower(make_string_ptr("EXECUTE"));

long FnvHash::Constants::SOURCE = FnvHash::fnv1a_64_lower(make_string_ptr("SOURCE"));

long FnvHash::Constants::STAR = FnvHash::fnv1a_64_lower(make_string_ptr("*"));

long FnvHash::Constants::TO_CHAR = FnvHash::fnv1a_64_lower(make_string_ptr("TO_CHAR"));
long FnvHash::Constants::UNIX_TIMESTAMP = FnvHash::fnv1a_64_lower(make_string_ptr("UNIX_TIMESTAMP"));
long FnvHash::Constants::FROM_UNIXTIME = FnvHash::fnv1a_64_lower(make_string_ptr("FROM_UNIXTIME"));
long FnvHash::Constants::TO_UNIXTIME = FnvHash::fnv1a_64_lower(make_string_ptr("TO_UNIXTIME"));
long FnvHash::Constants::SYS_GUID = FnvHash::fnv1a_64_lower(make_string_ptr("SYS_GUID"));
long FnvHash::Constants::LAST_DAY = FnvHash::fnv1a_64_lower(make_string_ptr("LAST_DAY"));
long FnvHash::Constants::MAKEDATE = FnvHash::fnv1a_64_lower(make_string_ptr("MAKEDATE"));
long FnvHash::Constants::ASCII = FnvHash::fnv1a_64_lower(make_string_ptr("ASCII"));
long FnvHash::Constants::DAYNAME = FnvHash::fnv1a_64_lower(make_string_ptr("DAYNAME"));

long FnvHash::Constants::STATISTICS = FnvHash::fnv1a_64_lower(make_string_ptr("STATISTICS"));
long FnvHash::Constants::TRANSACTION = FnvHash::fnv1a_64_lower(make_string_ptr("TRANSACTION"));
long FnvHash::Constants::OFF = FnvHash::fnv1a_64_lower(make_string_ptr("OFF"));
long FnvHash::Constants::IDENTITY_INSERT = FnvHash::fnv1a_64_lower(make_string_ptr("IDENTITY_INSERT"));
long FnvHash::Constants::PASSWORD = FnvHash::fnv1a_64_lower(make_string_ptr("PASSWORD"));
long FnvHash::Constants::SOCKET = FnvHash::fnv1a_64_lower(make_string_ptr("SOCKET"));
long FnvHash::Constants::OWNER = FnvHash::fnv1a_64_lower(make_string_ptr("OWNER"));
long FnvHash::Constants::PORT = FnvHash::fnv1a_64_lower(make_string_ptr("PORT"));
long FnvHash::Constants::PUBLIC = FnvHash::fnv1a_64_lower(make_string_ptr("PUBLIC"));
long FnvHash::Constants::SYNONYM = FnvHash::fnv1a_64_lower(make_string_ptr("SYNONYM"));
long FnvHash::Constants::MATERIALIZED = FnvHash::fnv1a_64_lower(make_string_ptr("MATERIALIZED"));
long FnvHash::Constants::BITMAP = FnvHash::fnv1a_64_lower(make_string_ptr("BITMAP"));
long FnvHash::Constants::LABEL = FnvHash::fnv1a_64_lower(make_string_ptr("LABEL"));
long FnvHash::Constants::PACKAGE = FnvHash::fnv1a_64_lower(make_string_ptr("PACKAGE"));
long FnvHash::Constants::PACKAGES = FnvHash::fnv1a_64_lower(make_string_ptr("PACKAGES"));
long FnvHash::Constants::TRUNC = FnvHash::fnv1a_64_lower(make_string_ptr("TRUNC"));
long FnvHash::Constants::SYSTIMESTAMP = FnvHash::fnv1a_64_lower(make_string_ptr("SYSTIMESTAMP"));
long FnvHash::Constants::TYPE = FnvHash::fnv1a_64_lower(make_string_ptr("TYPE"));
long FnvHash::Constants::RECORD = FnvHash::fnv1a_64_lower(make_string_ptr("RECORD"));
long FnvHash::Constants::MAP = FnvHash::fnv1a_64_lower(make_string_ptr("MAP"));
long FnvHash::Constants::MAPJOIN = FnvHash::fnv1a_64_lower(make_string_ptr("MAPJOIN"));
long FnvHash::Constants::MAPPED = FnvHash::fnv1a_64_lower(make_string_ptr("MAPPED"));
long FnvHash::Constants::MAPPING = FnvHash::fnv1a_64_lower(make_string_ptr("MAPPING"));
long FnvHash::Constants::COLPROPERTIES = FnvHash::fnv1a_64_lower(make_string_ptr("COLPROPERTIES"));
long FnvHash::Constants::ONLY = FnvHash::fnv1a_64_lower(make_string_ptr("ONLY"));
long FnvHash::Constants::MEMBER = FnvHash::fnv1a_64_lower(make_string_ptr("MEMBER"));
long FnvHash::Constants::STATIC = FnvHash::fnv1a_64_lower(make_string_ptr("STATIC"));
long FnvHash::Constants::FINAL = FnvHash::fnv1a_64_lower(make_string_ptr("FINAL"));
long FnvHash::Constants::INSTANTIABLE = FnvHash::fnv1a_64_lower(make_string_ptr("INSTANTIABLE"));
long FnvHash::Constants::UNSUPPORTED = FnvHash::fnv1a_64_lower(make_string_ptr("UNSUPPORTED"));
long FnvHash::Constants::VARRAY = FnvHash::fnv1a_64_lower(make_string_ptr("VARRAY"));
long FnvHash::Constants::WRAPPED = FnvHash::fnv1a_64_lower(make_string_ptr("WRAPPED"));
long FnvHash::Constants::AUTHID = FnvHash::fnv1a_64_lower(make_string_ptr("AUTHID"));
long FnvHash::Constants::UNDER = FnvHash::fnv1a_64_lower(make_string_ptr("UNDER"));
long FnvHash::Constants::USERENV = FnvHash::fnv1a_64_lower(make_string_ptr("USERENV"));
long FnvHash::Constants::NUMTODSINTERVAL = FnvHash::fnv1a_64_lower(make_string_ptr("NUMTODSINTERVAL"));

long FnvHash::Constants::LATERAL = FnvHash::fnv1a_64_lower(make_string_ptr("LATERAL"));
long FnvHash::Constants::NONE = FnvHash::fnv1a_64_lower(make_string_ptr("NONE"));
long FnvHash::Constants::PARTITIONING = FnvHash::fnv1a_64_lower(make_string_ptr("PARTITIONING"));
long FnvHash::Constants::VALIDPROC = FnvHash::fnv1a_64_lower(make_string_ptr("VALIDPROC"));
long FnvHash::Constants::COMPRESS = FnvHash::fnv1a_64_lower(make_string_ptr("COMPRESS"));
long FnvHash::Constants::YES = FnvHash::fnv1a_64_lower(make_string_ptr("YES"));
long FnvHash::Constants::WMSYS = FnvHash::fnv1a_64_lower(make_string_ptr("WMSYS"));

long FnvHash::Constants::DEPTH = FnvHash::fnv1a_64_lower(make_string_ptr("DEPTH"));
long FnvHash::Constants::BREADTH = FnvHash::fnv1a_64_lower(make_string_ptr("BREADTH"));

long FnvHash::Constants::SCHEDULE = FnvHash::fnv1a_64_lower(make_string_ptr("SCHEDULE"));
long FnvHash::Constants::COMPLETION = FnvHash::fnv1a_64_lower(make_string_ptr("COMPLETION"));
long FnvHash::Constants::RENAME = FnvHash::fnv1a_64_lower(make_string_ptr("RENAME"));
long FnvHash::Constants::AT = FnvHash::fnv1a_64_lower(make_string_ptr("AT"));
long FnvHash::Constants::LANGUAGE = FnvHash::fnv1a_64_lower(make_string_ptr("LANGUAGE"));
long FnvHash::Constants::LOGFILE = FnvHash::fnv1a_64_lower(make_string_ptr("LOGFILE"));
long FnvHash::Constants::LOG = FnvHash::fnv1a_64_lower(make_string_ptr("LOG"));
long FnvHash::Constants::INITIAL_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("INITIAL_SIZE"));
long FnvHash::Constants::MAX_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("MAX_SIZE"));
long FnvHash::Constants::NODEGROUP = FnvHash::fnv1a_64_lower(make_string_ptr("NODEGROUP"));
long FnvHash::Constants::EXTENT_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("EXTENT_SIZE"));
long FnvHash::Constants::AUTOEXTEND_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("AUTOEXTEND_SIZE"));
long FnvHash::Constants::FILE_BLOCK_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("FILE_BLOCK_SIZE"));
long FnvHash::Constants::BLOCK_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("BLOCK_SIZE"));
long FnvHash::Constants::REPLICA_NUM = FnvHash::fnv1a_64_lower(make_string_ptr("REPLICA_NUM"));
long FnvHash::Constants::TABLET_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("TABLET_SIZE"));
long FnvHash::Constants::PCTFREE = FnvHash::fnv1a_64_lower(make_string_ptr("PCTFREE"));
long FnvHash::Constants::USE_BLOOM_FILTER = FnvHash::fnv1a_64_lower(make_string_ptr("USE_BLOOM_FILTER"));
long FnvHash::Constants::SERVER = FnvHash::fnv1a_64_lower(make_string_ptr("SERVER"));
long FnvHash::Constants::HOST = FnvHash::fnv1a_64_lower(make_string_ptr("HOST"));
long FnvHash::Constants::ADD = FnvHash::fnv1a_64_lower(make_string_ptr("ADD"));
long FnvHash::Constants::REMOVE = FnvHash::fnv1a_64_lower(make_string_ptr("REMOVE"));
long FnvHash::Constants::MOVE = FnvHash::fnv1a_64_lower(make_string_ptr("MOVE"));
long FnvHash::Constants::ALGORITHM = FnvHash::fnv1a_64_lower(make_string_ptr("ALGORITHM"));
long FnvHash::Constants::LINEAR = FnvHash::fnv1a_64_lower(make_string_ptr("LINEAR"));
long FnvHash::Constants::EVERY = FnvHash::fnv1a_64_lower(make_string_ptr("EVERY"));
long FnvHash::Constants::STARTS = FnvHash::fnv1a_64_lower(make_string_ptr("STARTS"));
long FnvHash::Constants::ENDS = FnvHash::fnv1a_64_lower(make_string_ptr("ENDS"));
long FnvHash::Constants::BINARY = FnvHash::fnv1a_64_lower(make_string_ptr("BINARY"));
long FnvHash::Constants::GEOMETRY = FnvHash::fnv1a_64_lower(make_string_ptr("GEOMETRY"));
long FnvHash::Constants::ISOPEN = FnvHash::fnv1a_64_lower(make_string_ptr("ISOPEN"));
long FnvHash::Constants::CONFLICT = FnvHash::fnv1a_64_lower(make_string_ptr("CONFLICT"));
long FnvHash::Constants::NOTHING = FnvHash::fnv1a_64_lower(make_string_ptr("NOTHING"));
long FnvHash::Constants::COMMIT = FnvHash::fnv1a_64_lower(make_string_ptr("COMMIT"));
long FnvHash::Constants::DESCRIBE = FnvHash::fnv1a_64_lower(make_string_ptr("DESCRIBE"));
long FnvHash::Constants::SQLXML = FnvHash::fnv1a_64_lower(make_string_ptr("SQLXML"));
long FnvHash::Constants::BIT = FnvHash::fnv1a_64_lower(make_string_ptr("BIT"));
long FnvHash::Constants::LONGBLOB = FnvHash::fnv1a_64_lower(make_string_ptr("LONGBLOB"));

long FnvHash::Constants::RS = FnvHash::fnv1a_64_lower(make_string_ptr("RS"));
long FnvHash::Constants::RR = FnvHash::fnv1a_64_lower(make_string_ptr("RR"));
long FnvHash::Constants::CS = FnvHash::fnv1a_64_lower(make_string_ptr("CS"));
long FnvHash::Constants::UR = FnvHash::fnv1a_64_lower(make_string_ptr("UR"));

long FnvHash::Constants::INT4 = FnvHash::fnv1a_64_lower(make_string_ptr("INT4"));
long FnvHash::Constants::VARBIT = FnvHash::fnv1a_64_lower(make_string_ptr("VARBIT"));
long FnvHash::Constants::DECODE = FnvHash::fnv1a_64_lower(make_string_ptr("DECODE"));
long FnvHash::Constants::IF = FnvHash::fnv1a_64_lower(make_string_ptr("IF"));
long FnvHash::Constants::FUNCTION = FnvHash::fnv1a_64_lower(make_string_ptr("FUNCTION"));
long FnvHash::Constants::EXTERNAL = FnvHash::fnv1a_64_lower(make_string_ptr("EXTERNAL"));
long FnvHash::Constants::SORTED = FnvHash::fnv1a_64_lower(make_string_ptr("SORTED"));
long FnvHash::Constants::CLUSTERED = FnvHash::fnv1a_64_lower(make_string_ptr("CLUSTERED"));
long FnvHash::Constants::LIFECYCLE = FnvHash::fnv1a_64_lower(make_string_ptr("LIFECYCLE"));
long FnvHash::Constants::LOCATION = FnvHash::fnv1a_64_lower(make_string_ptr("LOCATION"));
long FnvHash::Constants::PARTITIONS = FnvHash::fnv1a_64_lower(make_string_ptr("PARTITIONS"));
long FnvHash::Constants::FORMAT = FnvHash::fnv1a_64_lower(make_string_ptr("FORMAT"));
long FnvHash::Constants::ENCODE = FnvHash::fnv1a_64_lower(make_string_ptr("ENCODE"));

long FnvHash::Constants::SELECT = FnvHash::fnv1a_64_lower(make_string_ptr("SELECT"));
long FnvHash::Constants::DELETE = FnvHash::fnv1a_64_lower(make_string_ptr("DELETE"));
long FnvHash::Constants::UPDATE = FnvHash::fnv1a_64_lower(make_string_ptr("UPDATE"));
long FnvHash::Constants::INSERT = FnvHash::fnv1a_64_lower(make_string_ptr("INSERT"));
long FnvHash::Constants::REPLACE = FnvHash::fnv1a_64_lower(make_string_ptr("REPLACE"));
long FnvHash::Constants::TRUNCATE = FnvHash::fnv1a_64_lower(make_string_ptr("TRUNCATE"));
long FnvHash::Constants::CREATE = FnvHash::fnv1a_64_lower(make_string_ptr("CREATE"));
long FnvHash::Constants::MERGE = FnvHash::fnv1a_64_lower(make_string_ptr("MERGE"));
long FnvHash::Constants::SHOW = FnvHash::fnv1a_64_lower(make_string_ptr("SHOW"));
long FnvHash::Constants::ALTER = FnvHash::fnv1a_64_lower(make_string_ptr("ALTER"));
long FnvHash::Constants::DESC = FnvHash::fnv1a_64_lower(make_string_ptr("DESC"));
long FnvHash::Constants::SET = FnvHash::fnv1a_64_lower(make_string_ptr("SET"));
long FnvHash::Constants::KILL = FnvHash::fnv1a_64_lower(make_string_ptr("KILL"));
long FnvHash::Constants::MSCK = FnvHash::fnv1a_64_lower(make_string_ptr("MSCK"));
long FnvHash::Constants::USE = FnvHash::fnv1a_64_lower(make_string_ptr("USE"));
long FnvHash::Constants::ROLLBACK = FnvHash::fnv1a_64_lower(make_string_ptr("ROLLBACK"));
long FnvHash::Constants::GRANT = FnvHash::fnv1a_64_lower(make_string_ptr("GRANT"));
long FnvHash::Constants::REVOKE = FnvHash::fnv1a_64_lower(make_string_ptr("REVOKE"));
long FnvHash::Constants::DROP = FnvHash::fnv1a_64_lower(make_string_ptr("DROP"));
long FnvHash::Constants::USER = FnvHash::fnv1a_64_lower(make_string_ptr("USER"));

long FnvHash::Constants::USAGE = FnvHash::fnv1a_64_lower(make_string_ptr("USAGE"));
long FnvHash::Constants::PCTUSED = FnvHash::fnv1a_64_lower(make_string_ptr("PCTUSED"));
long FnvHash::Constants::OPAQUE = FnvHash::fnv1a_64_lower(make_string_ptr("OPAQUE"));
long FnvHash::Constants::INHERITS = FnvHash::fnv1a_64_lower(make_string_ptr("INHERITS"));
long FnvHash::Constants::DELIMITED = FnvHash::fnv1a_64_lower(make_string_ptr("DELIMITED"));
long FnvHash::Constants::ARRAY = FnvHash::fnv1a_64_lower(make_string_ptr("ARRAY"));
long FnvHash::Constants::SCALAR = FnvHash::fnv1a_64_lower(make_string_ptr("SCALAR"));
long FnvHash::Constants::STRUCT = FnvHash::fnv1a_64_lower(make_string_ptr("STRUCT"));
long FnvHash::Constants::TABLE = FnvHash::fnv1a_64_lower(make_string_ptr("TABLE"));
long FnvHash::Constants::UNIONTYPE = FnvHash::fnv1a_64_lower(make_string_ptr("UNIONTYPE"));

long FnvHash::Constants::TDDL = FnvHash::fnv1a_64_lower(make_string_ptr("TDDL"));
long FnvHash::Constants::CONCURRENTLY = FnvHash::fnv1a_64_lower(make_string_ptr("CONCURRENTLY"));
long FnvHash::Constants::TABLES = FnvHash::fnv1a_64_lower(make_string_ptr("TABLES"));
long FnvHash::Constants::ROLES = FnvHash::fnv1a_64_lower(make_string_ptr("ROLES"));
long FnvHash::Constants::NOCACHE = FnvHash::fnv1a_64_lower(make_string_ptr("NOCACHE"));
long FnvHash::Constants::NOPARALLEL = FnvHash::fnv1a_64_lower(make_string_ptr("NOPARALLEL"));
long FnvHash::Constants::EXIST = FnvHash::fnv1a_64_lower(make_string_ptr("EXIST"));
long FnvHash::Constants::EXISTS = FnvHash::fnv1a_64_lower(make_string_ptr("EXISTS"));
long FnvHash::Constants::SOUNDS = FnvHash::fnv1a_64_lower(make_string_ptr("SOUNDS"));
long FnvHash::Constants::TBLPROPERTIES = FnvHash::fnv1a_64_lower(make_string_ptr("TBLPROPERTIES"));
long FnvHash::Constants::TABLEGROUP = FnvHash::fnv1a_64_lower(make_string_ptr("TABLEGROUP"));
long FnvHash::Constants::TABLEGROUPS = FnvHash::fnv1a_64_lower(make_string_ptr("TABLEGROUPS"));
long FnvHash::Constants::DIMENSION = FnvHash::fnv1a_64_lower(make_string_ptr("DIMENSION"));
long FnvHash::Constants::OPTIONS = FnvHash::fnv1a_64_lower(make_string_ptr("OPTIONS"));
long FnvHash::Constants::OPTIMIZER = FnvHash::fnv1a_64_lower(make_string_ptr("OPTIMIZER"));

long FnvHash::Constants::FULLTEXT = FnvHash::fnv1a_64_lower(make_string_ptr("FULLTEXT"));
long FnvHash::Constants::SPATIAL = FnvHash::fnv1a_64_lower(make_string_ptr("SPATIAL"));

long FnvHash::Constants::SUBPARTITION_AVAILABLE_PARTITION_NUM = FnvHash::fnv1a_64_lower(make_string_ptr("SUBPARTITION_AVAILABLE_PARTITION_NUM"));
long FnvHash::Constants::EXTRA = FnvHash::fnv1a_64_lower(make_string_ptr("EXTRA"));
long FnvHash::Constants::DATABASES = FnvHash::fnv1a_64_lower(make_string_ptr("DATABASES"));
long FnvHash::Constants::COLUMNS = FnvHash::fnv1a_64_lower(make_string_ptr("COLUMNS"));
long FnvHash::Constants::PROCESS = FnvHash::fnv1a_64_lower(make_string_ptr("PROCESS"));
long FnvHash::Constants::PROCESSLIST = FnvHash::fnv1a_64_lower(make_string_ptr("PROCESSLIST"));
long FnvHash::Constants::MPP = FnvHash::fnv1a_64_lower(make_string_ptr("MPP"));
long FnvHash::Constants::SERDE = FnvHash::fnv1a_64_lower(make_string_ptr("SERDE"));
long FnvHash::Constants::SORT = FnvHash::fnv1a_64_lower(make_string_ptr("SORT"));
long FnvHash::Constants::ZORDER = FnvHash::fnv1a_64_lower(make_string_ptr("ZORDER"));
long FnvHash::Constants::FIELDS = FnvHash::fnv1a_64_lower(make_string_ptr("FIELDS"));
long FnvHash::Constants::COLLECTION = FnvHash::fnv1a_64_lower(make_string_ptr("COLLECTION"));
long FnvHash::Constants::SKEWED = FnvHash::fnv1a_64_lower(make_string_ptr("SKEWED"));
long FnvHash::Constants::SYMBOL = FnvHash::fnv1a_64_lower(make_string_ptr("SYMBOL"));
long FnvHash::Constants::LOAD = FnvHash::fnv1a_64_lower(make_string_ptr("LOAD"));
long FnvHash::Constants::VIEWS = FnvHash::fnv1a_64_lower(make_string_ptr("VIEWS"));
long FnvHash::Constants::SUBSTR = FnvHash::fnv1a_64_lower(make_string_ptr("SUBSTR"));
long FnvHash::Constants::TO_BASE64 = FnvHash::fnv1a_64_lower(make_string_ptr("TO_BASE64"));
long FnvHash::Constants::REGEXP_SUBSTR = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_SUBSTR"));
long FnvHash::Constants::REGEXP_COUNT = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_COUNT"));
long FnvHash::Constants::REGEXP_EXTRACT = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_EXTRACT"));
long FnvHash::Constants::REGEXP_EXTRACT_ALL = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_EXTRACT_ALL"));
long FnvHash::Constants::REGEXP_LIKE = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_LIKE"));
long FnvHash::Constants::REGEXP_REPLACE = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_REPLACE"));
long FnvHash::Constants::REGEXP_SPLIT = FnvHash::fnv1a_64_lower(make_string_ptr("REGEXP_SPLIT"));
long FnvHash::Constants::CONCAT = FnvHash::fnv1a_64_lower(make_string_ptr("CONCAT"));
long FnvHash::Constants::LCASE = FnvHash::fnv1a_64_lower(make_string_ptr("LCASE"));
long FnvHash::Constants::UCASE = FnvHash::fnv1a_64_lower(make_string_ptr("UCASE"));
long FnvHash::Constants::LOWER = FnvHash::fnv1a_64_lower(make_string_ptr("LOWER"));
long FnvHash::Constants::UPPER = FnvHash::fnv1a_64_lower(make_string_ptr("UPPER"));
long FnvHash::Constants::LENGTH = FnvHash::fnv1a_64_lower(make_string_ptr("LENGTH"));
long FnvHash::Constants::LOCATE = FnvHash::fnv1a_64_lower(make_string_ptr("LOCATE"));
long FnvHash::Constants::UDF_SYS_ROWCOUNT = FnvHash::fnv1a_64_lower(make_string_ptr("UDF_SYS_ROWCOUNT"));
long FnvHash::Constants::CHAR_LENGTH = FnvHash::fnv1a_64_lower(make_string_ptr("CHAR_LENGTH"));
long FnvHash::Constants::CHARACTER_LENGTH = FnvHash::fnv1a_64_lower(make_string_ptr("CHARACTER_LENGTH"));
long FnvHash::Constants::SUBSTRING = FnvHash::fnv1a_64_lower(make_string_ptr("SUBSTRING"));
long FnvHash::Constants::SUBSTRING_INDEX = FnvHash::fnv1a_64_lower(make_string_ptr("SUBSTRING_INDEX"));
long FnvHash::Constants::LEFT = FnvHash::fnv1a_64_lower(make_string_ptr("LEFT"));
long FnvHash::Constants::RIGHT = FnvHash::fnv1a_64_lower(make_string_ptr("RIGHT"));
long FnvHash::Constants::RTRIM = FnvHash::fnv1a_64_lower(make_string_ptr("RTRIM"));
long FnvHash::Constants::LEN = FnvHash::fnv1a_64_lower(make_string_ptr("LEN"));
long FnvHash::Constants::GREAST = FnvHash::fnv1a_64_lower(make_string_ptr("GREAST"));
long FnvHash::Constants::LEAST = FnvHash::fnv1a_64_lower(make_string_ptr("LEAST"));
long FnvHash::Constants::IFNULL = FnvHash::fnv1a_64_lower(make_string_ptr("IFNULL"));
long FnvHash::Constants::NULLIF = FnvHash::fnv1a_64_lower(make_string_ptr("NULLIF"));
long FnvHash::Constants::GREATEST = FnvHash::fnv1a_64_lower(make_string_ptr("GREATEST"));
long FnvHash::Constants::COALESCE = FnvHash::fnv1a_64_lower(make_string_ptr("COALESCE"));
long FnvHash::Constants::ISNULL = FnvHash::fnv1a_64_lower(make_string_ptr("ISNULL"));
long FnvHash::Constants::NVL = FnvHash::fnv1a_64_lower(make_string_ptr("NVL"));
long FnvHash::Constants::NVL2 = FnvHash::fnv1a_64_lower(make_string_ptr("NVL2"));
long FnvHash::Constants::TO_DATE = FnvHash::fnv1a_64_lower(make_string_ptr("TO_DATE"));
long FnvHash::Constants::DATEADD = FnvHash::fnv1a_64_lower(make_string_ptr("DATEADD"));
long FnvHash::Constants::DATE_ADD = FnvHash::fnv1a_64_lower(make_string_ptr("DATE_ADD"));
long FnvHash::Constants::ADDDATE = FnvHash::fnv1a_64_lower(make_string_ptr("ADDDATE"));
long FnvHash::Constants::DATE_SUB = FnvHash::fnv1a_64_lower(make_string_ptr("DATE_SUB"));
long FnvHash::Constants::SUBDATE = FnvHash::fnv1a_64_lower(make_string_ptr("SUBDATE"));
long FnvHash::Constants::DATE_PARSE = FnvHash::fnv1a_64_lower(make_string_ptr("DATE_PARSE"));
long FnvHash::Constants::STR_TO_DATE = FnvHash::fnv1a_64_lower(make_string_ptr("STR_TO_DATE"));
long FnvHash::Constants::CLOTHES_FEATURE_EXTRACT_V1 = FnvHash::fnv1a_64_lower(make_string_ptr("CLOTHES_FEATURE_EXTRACT_V1"));
long FnvHash::Constants::CLOTHES_ATTRIBUTE_EXTRACT_V1 = FnvHash::fnv1a_64_lower(make_string_ptr("CLOTHES_ATTRIBUTE_EXTRACT_V1"));

long FnvHash::Constants::GENERIC_FEATURE_EXTRACT_V1 = FnvHash::fnv1a_64_lower(make_string_ptr("GENERIC_FEATURE_EXTRACT_V1"));
long FnvHash::Constants::FACE_FEATURE_EXTRACT_V1 = FnvHash::fnv1a_64_lower(make_string_ptr("FACE_FEATURE_EXTRACT_V1"));
long FnvHash::Constants::TEXT_FEATURE_EXTRACT_V1 = FnvHash::fnv1a_64_lower(make_string_ptr("TEXT_FEATURE_EXTRACT_V1"));

long FnvHash::Constants::JSON_TABLE = FnvHash::fnv1a_64_lower(make_string_ptr("JSON_TABLE"));
long FnvHash::Constants::JSON_EXTRACT = FnvHash::fnv1a_64_lower(make_string_ptr("JSON_EXTRACT"));
long FnvHash::Constants::JSON_EXTRACT_SCALAR = FnvHash::fnv1a_64_lower(make_string_ptr("json_extract_scalar"));
long FnvHash::Constants::JSON_ARRAY_GET = FnvHash::fnv1a_64_lower(make_string_ptr("JSON_ARRAY_GET"));
long FnvHash::Constants::ADD_MONTHS = FnvHash::fnv1a_64_lower(make_string_ptr("ADD_MONTHS"));
long FnvHash::Constants::ABS = FnvHash::fnv1a_64_lower(make_string_ptr("ABS"));
long FnvHash::Constants::ACOS = FnvHash::fnv1a_64_lower(make_string_ptr("ACOS"));
long FnvHash::Constants::ASIN = FnvHash::fnv1a_64_lower(make_string_ptr("ASIN"));
long FnvHash::Constants::ATAN = FnvHash::fnv1a_64_lower(make_string_ptr("ATAN"));
long FnvHash::Constants::ATAN2 = FnvHash::fnv1a_64_lower(make_string_ptr("ATAN2"));
long FnvHash::Constants::COS = FnvHash::fnv1a_64_lower(make_string_ptr("COS"));
long FnvHash::Constants::FLOOR = FnvHash::fnv1a_64_lower(make_string_ptr("FLOOR"));
long FnvHash::Constants::CEIL = FnvHash::fnv1a_64_lower(make_string_ptr("CEIL"));
long FnvHash::Constants::SQRT = FnvHash::fnv1a_64_lower(make_string_ptr("SQRT"));
long FnvHash::Constants::LEAD = FnvHash::fnv1a_64_lower(make_string_ptr("LEAD"));
long FnvHash::Constants::LAG = FnvHash::fnv1a_64_lower(make_string_ptr("LAG"));
long FnvHash::Constants::CEILING = FnvHash::fnv1a_64_lower(make_string_ptr("CEILING"));
long FnvHash::Constants::POWER = FnvHash::fnv1a_64_lower(make_string_ptr("POWER"));
long FnvHash::Constants::EXP = FnvHash::fnv1a_64_lower(make_string_ptr("EXP"));
long FnvHash::Constants::LN = FnvHash::fnv1a_64_lower(make_string_ptr("LN"));
long FnvHash::Constants::LOG10 = FnvHash::fnv1a_64_lower(make_string_ptr("LOG10"));
long FnvHash::Constants::INTERVAL = FnvHash::fnv1a_64_lower(make_string_ptr("INTERVAL"));
long FnvHash::Constants::FROM_DAYS = FnvHash::fnv1a_64_lower(make_string_ptr("FROM_DAYS"));
long FnvHash::Constants::TO_DAYS = FnvHash::fnv1a_64_lower(make_string_ptr("TO_DAYS"));

long FnvHash::Constants::BIGINT = FnvHash::fnv1a_64_lower(make_string_ptr("BIGINT"));
long FnvHash::Constants::LONGLONG = FnvHash::fnv1a_64_lower(make_string_ptr("LONGLONG"));
long FnvHash::Constants::DISCARD = FnvHash::fnv1a_64_lower(make_string_ptr("DISCARD"));
long FnvHash::Constants::EXCHANGE = FnvHash::fnv1a_64_lower(make_string_ptr("EXCHANGE"));
long FnvHash::Constants::ROLE = FnvHash::fnv1a_64_lower(make_string_ptr("ROLE"));
long FnvHash::Constants::OVERWRITE = FnvHash::fnv1a_64_lower(make_string_ptr("OVERWRITE"));
long FnvHash::Constants::NO = FnvHash::fnv1a_64_lower(make_string_ptr("NO"));
long FnvHash::Constants::CATALOG = FnvHash::fnv1a_64_lower(make_string_ptr("CATALOG"));
long FnvHash::Constants::CATALOGS = FnvHash::fnv1a_64_lower(make_string_ptr("CATALOGS"));
long FnvHash::Constants::FUNCTIONS = FnvHash::fnv1a_64_lower(make_string_ptr("FUNCTIONS"));
long FnvHash::Constants::SCHEMAS = FnvHash::fnv1a_64_lower(make_string_ptr("SCHEMAS"));
long FnvHash::Constants::CHANGE = FnvHash::fnv1a_64_lower(make_string_ptr("CHANGE"));
long FnvHash::Constants::MODIFY = FnvHash::fnv1a_64_lower(make_string_ptr("MODIFY"));
long FnvHash::Constants::BEGIN = FnvHash::fnv1a_64_lower(make_string_ptr("BEGIN"));
long FnvHash::Constants::PATH = FnvHash::fnv1a_64_lower(make_string_ptr("PATH"));
long FnvHash::Constants::ENCRYPTION = FnvHash::fnv1a_64_lower(make_string_ptr("ENCRYPTION"));
long FnvHash::Constants::COMPRESSION = FnvHash::fnv1a_64_lower(make_string_ptr("COMPRESSION"));
long FnvHash::Constants::KEY_BLOCK_SIZE = FnvHash::fnv1a_64_lower(make_string_ptr("KEY_BLOCK_SIZE"));
long FnvHash::Constants::CHECKSUM = FnvHash::fnv1a_64_lower(make_string_ptr("CHECKSUM"));
long FnvHash::Constants::CONNECTION = FnvHash::fnv1a_64_lower(make_string_ptr("CONNECTION"));
long FnvHash::Constants::DATASOURCES = FnvHash::fnv1a_64_lower(make_string_ptr("DATASOURCES"));
long FnvHash::Constants::NODE = FnvHash::fnv1a_64_lower(make_string_ptr("NODE"));
long FnvHash::Constants::HELP = FnvHash::fnv1a_64_lower(make_string_ptr("HELP"));
long FnvHash::Constants::BROADCASTS = FnvHash::fnv1a_64_lower(make_string_ptr("BROADCASTS"));
long FnvHash::Constants::MASTER = FnvHash::fnv1a_64_lower(make_string_ptr("MASTER"));
long FnvHash::Constants::SLAVE = FnvHash::fnv1a_64_lower(make_string_ptr("SLAVE"));
long FnvHash::Constants::SQL_DELAY_CUTOFF = FnvHash::fnv1a_64_lower(make_string_ptr("SQL_DELAY_CUTOFF"));
long FnvHash::Constants::SOCKET_TIMEOUT = FnvHash::fnv1a_64_lower(make_string_ptr("SOCKET_TIMEOUT"));
long FnvHash::Constants::FORBID_EXECUTE_DML_ALL = FnvHash::fnv1a_64_lower(make_string_ptr("FORBID_EXECUTE_DML_ALL"));
long FnvHash::Constants::SCAN = FnvHash::fnv1a_64_lower(make_string_ptr("SCAN"));
long FnvHash::Constants::NOLOGFILE = FnvHash::fnv1a_64_lower(make_string_ptr("NOLOGFILE"));
long FnvHash::Constants::NOBADFILE = FnvHash::fnv1a_64_lower(make_string_ptr("NOBADFILE"));
long FnvHash::Constants::TERMINATED = FnvHash::fnv1a_64_lower(make_string_ptr("TERMINATED"));
long FnvHash::Constants::LTRIM = FnvHash::fnv1a_64_lower(make_string_ptr("LTRIM"));
long FnvHash::Constants::MISSING = FnvHash::fnv1a_64_lower(make_string_ptr("MISSING"));
long FnvHash::Constants::SUBPARTITION = FnvHash::fnv1a_64_lower(make_string_ptr("SUBPARTITION"));
long FnvHash::Constants::SUBPARTITIONS = FnvHash::fnv1a_64_lower(make_string_ptr("SUBPARTITIONS"));
long FnvHash::Constants::GENERATED = FnvHash::fnv1a_64_lower(make_string_ptr("GENERATED"));
long FnvHash::Constants::ALWAYS = FnvHash::fnv1a_64_lower(make_string_ptr("ALWAYS"));
long FnvHash::Constants::VISIBLE = FnvHash::fnv1a_64_lower(make_string_ptr("VISIBLE"));
long FnvHash::Constants::INCLUDING = FnvHash::fnv1a_64_lower(make_string_ptr("INCLUDING"));
long FnvHash::Constants::EXCLUDE = FnvHash::fnv1a_64_lower(make_string_ptr("EXCLUDE"));
long FnvHash::Constants::EXCLUDING = FnvHash::fnv1a_64_lower(make_string_ptr("EXCLUDING"));
long FnvHash::Constants::ROUTINE = FnvHash::fnv1a_64_lower(make_string_ptr("ROUTINE"));
long FnvHash::Constants::IDENTIFIED = FnvHash::fnv1a_64_lower(make_string_ptr("IDENTIFIED"));
long FnvHash::Constants::DELIMITER = FnvHash::fnv1a_64_lower(make_string_ptr("DELIMITER"));
long FnvHash::Constants::UNKNOWN = FnvHash::fnv1a_64_lower(make_string_ptr("UNKNOWN"));
long FnvHash::Constants::WEIGHT_STRING = FnvHash::fnv1a_64_lower(make_string_ptr("WEIGHT_STRING"));
long FnvHash::Constants::REVERSE = FnvHash::fnv1a_64_lower(make_string_ptr("REVERSE"));
long FnvHash::Constants::DATE_FORMAT = FnvHash::fnv1a_64_lower(make_string_ptr("DATE_FORMAT"));
long FnvHash::Constants::DAY_OF_WEEK = FnvHash::fnv1a_64_lower(make_string_ptr("DAY_OF_WEEK"));
long FnvHash::Constants::DATEDIFF = FnvHash::fnv1a_64_lower(make_string_ptr("DATEDIFF"));
long FnvHash::Constants::GET_FORMAT = FnvHash::fnv1a_64_lower(make_string_ptr("GET_FORMAT"));
long FnvHash::Constants::TIMESTAMPDIFF = FnvHash::fnv1a_64_lower(make_string_ptr("TIMESTAMPDIFF"));
long FnvHash::Constants::MONTHNAME = FnvHash::fnv1a_64_lower(make_string_ptr("MONTHNAME"));
long FnvHash::Constants::PERIOD_ADD = FnvHash::fnv1a_64_lower(make_string_ptr("PERIOD_ADD"));
long FnvHash::Constants::PERIOD_DIFF = FnvHash::fnv1a_64_lower(make_string_ptr("PERIOD_DIFF"));
long FnvHash::Constants::ROUND = FnvHash::fnv1a_64_lower(make_string_ptr("ROUND"));
long FnvHash::Constants::DBPARTITION = FnvHash::fnv1a_64_lower(make_string_ptr("DBPARTITION"));
long FnvHash::Constants::TBPARTITION = FnvHash::fnv1a_64_lower(make_string_ptr("TBPARTITION"));
long FnvHash::Constants::EXTPARTITION = FnvHash::fnv1a_64_lower(make_string_ptr("EXTPARTITION"));
long FnvHash::Constants::STARTWITH = FnvHash::fnv1a_64_lower(make_string_ptr("STARTWITH"));
long FnvHash::Constants::TBPARTITIONS = FnvHash::fnv1a_64_lower(make_string_ptr("TBPARTITIONS"));
long FnvHash::Constants::DBPARTITIONS = FnvHash::fnv1a_64_lower(make_string_ptr("DBPARTITIONS"));
long FnvHash::Constants::PARTITIONED = FnvHash::fnv1a_64_lower(make_string_ptr("PARTITIONED"));
long FnvHash::Constants::PARALLEL = FnvHash::fnv1a_64_lower(make_string_ptr("PARALLEL"));
long FnvHash::Constants::ALLOW = FnvHash::fnv1a_64_lower(make_string_ptr("ALLOW"));
long FnvHash::Constants::DISALLOW = FnvHash::fnv1a_64_lower(make_string_ptr("DISALLOW"));
long FnvHash::Constants::PIVOT = FnvHash::fnv1a_64_lower(make_string_ptr("PIVOT"));
long FnvHash::Constants::MODEL = FnvHash::fnv1a_64_lower(make_string_ptr("MODEL"));
long FnvHash::Constants::KEEP = FnvHash::fnv1a_64_lower(make_string_ptr("KEEP"));
long FnvHash::Constants::REFERENCE = FnvHash::fnv1a_64_lower(make_string_ptr("REFERENCE"));
long FnvHash::Constants::RETURN = FnvHash::fnv1a_64_lower(make_string_ptr("RETURN"));
long FnvHash::Constants::RETURNS = FnvHash::fnv1a_64_lower(make_string_ptr("RETURNS"));
long FnvHash::Constants::ROWTYPE = FnvHash::fnv1a_64_lower(make_string_ptr("ROWTYPE"));
long FnvHash::Constants::WINDOW = FnvHash::fnv1a_64_lower(make_string_ptr("WINDOW"));
long FnvHash::Constants::QUALIFY = FnvHash::fnv1a_64_lower(make_string_ptr("QUALIFY"));
long FnvHash::Constants::MULTIVALUE = FnvHash::fnv1a_64_lower(make_string_ptr("MULTIVALUE"));
long FnvHash::Constants::OPTIONALLY = FnvHash::fnv1a_64_lower(make_string_ptr("OPTIONALLY"));
long FnvHash::Constants::ENCLOSED = FnvHash::fnv1a_64_lower(make_string_ptr("ENCLOSED"));
long FnvHash::Constants::ESCAPED = FnvHash::fnv1a_64_lower(make_string_ptr("ESCAPED"));
long FnvHash::Constants::ESCAPE = FnvHash::fnv1a_64_lower(make_string_ptr("ESCAPE"));
long FnvHash::Constants::LINES = FnvHash::fnv1a_64_lower(make_string_ptr("LINES"));
long FnvHash::Constants::STARTING = FnvHash::fnv1a_64_lower(make_string_ptr("STARTING"));
long FnvHash::Constants::DISTRIBUTE = FnvHash::fnv1a_64_lower(make_string_ptr("DISTRIBUTE"));
long FnvHash::Constants::DISTRIBUTED = FnvHash::fnv1a_64_lower(make_string_ptr("DISTRIBUTED"));
long FnvHash::Constants::CLUSTER = FnvHash::fnv1a_64_lower(make_string_ptr("CLUSTER"));
long FnvHash::Constants::RUNNING = FnvHash::fnv1a_64_lower(make_string_ptr("RUNNING"));
long FnvHash::Constants::CLUSTERING = FnvHash::fnv1a_64_lower(make_string_ptr("CLUSTERING"));
long FnvHash::Constants::PCTVERSION = FnvHash::fnv1a_64_lower(make_string_ptr("PCTVERSION"));
long FnvHash::Constants::IDENTITY = FnvHash::fnv1a_64_lower(make_string_ptr("IDENTITY"));
long FnvHash::Constants::INCREMENT = FnvHash::fnv1a_64_lower(make_string_ptr("INCREMENT"));
long FnvHash::Constants::MINVALUE = FnvHash::fnv1a_64_lower(make_string_ptr("MINVALUE"));
long FnvHash::Constants::ANN = FnvHash::fnv1a_64_lower(make_string_ptr("ANN"));
long FnvHash::Constants::ANN_DISTANCE = FnvHash::fnv1a_64_lower(make_string_ptr("ANN_DISTANCE"));
long FnvHash::Constants::SUPPLEMENTAL = FnvHash::fnv1a_64_lower(make_string_ptr("SUPPLEMENTAL"));
long FnvHash::Constants::SUBSTITUTABLE = FnvHash::fnv1a_64_lower(make_string_ptr("SUBSTITUTABLE"));
long FnvHash::Constants::BASICFILE = FnvHash::fnv1a_64_lower(make_string_ptr("BASICFILE"));
long FnvHash::Constants::IN_MEMORY_METADATA = FnvHash::fnv1a_64_lower(make_string_ptr("IN_MEMORY_METADATA"));
long FnvHash::Constants::CURSOR_SPECIFIC_SEGMENT = FnvHash::fnv1a_64_lower(make_string_ptr("CURSOR_SPECIFIC_SEGMENT"));
long FnvHash::Constants::DEFER = FnvHash::fnv1a_64_lower(make_string_ptr("DEFER"));
long FnvHash::Constants::UNDO_LOG_LIMIT = FnvHash::fnv1a_64_lower(make_string_ptr("UNDO_LOG_LIMIT"));
long FnvHash::Constants::DBPROPERTIES = FnvHash::fnv1a_64_lower(make_string_ptr("DBPROPERTIES"));
long FnvHash::Constants::ANNINDEX = FnvHash::fnv1a_64_lower(make_string_ptr("ANNINDEX"));
long FnvHash::Constants::RTTYPE = FnvHash::fnv1a_64_lower(make_string_ptr("RTTYPE"));
long FnvHash::Constants::DISTANCE = FnvHash::fnv1a_64_lower(make_string_ptr("DISTANCE"));
long FnvHash::Constants::IDXPROPERTIES = FnvHash::fnv1a_64_lower(make_string_ptr("IDXPROPERTIES"));
long FnvHash::Constants::RECOVER = FnvHash::fnv1a_64_lower(make_string_ptr("RECOVER"));
long FnvHash::Constants::BACKUP = FnvHash::fnv1a_64_lower(make_string_ptr("BACKUP"));
long FnvHash::Constants::RESTORE = FnvHash::fnv1a_64_lower(make_string_ptr("RESTORE"));
long FnvHash::Constants::EXSTORE = FnvHash::fnv1a_64_lower(make_string_ptr("EXSTORE"));
long FnvHash::Constants::UNDO = FnvHash::fnv1a_64_lower(make_string_ptr("UNDO"));
long FnvHash::Constants::NOSCAN = FnvHash::fnv1a_64_lower(make_string_ptr("NOSCAN"));
long FnvHash::Constants::EXTENDED = FnvHash::fnv1a_64_lower(make_string_ptr("EXTENDED"));
long FnvHash::Constants::FORMATTED = FnvHash::fnv1a_64_lower(make_string_ptr("FORMATTED"));
long FnvHash::Constants::DEPENDENCY = FnvHash::fnv1a_64_lower(make_string_ptr("DEPENDENCY"));
long FnvHash::Constants::AUTHORIZATION = FnvHash::fnv1a_64_lower(make_string_ptr("AUTHORIZATION"));
long FnvHash::Constants::ANALYZE = FnvHash::fnv1a_64_lower(make_string_ptr("ANALYZE"));
long FnvHash::Constants::EXPORT = FnvHash::fnv1a_64_lower(make_string_ptr("EXPORT"));
long FnvHash::Constants::IMPORT = FnvHash::fnv1a_64_lower(make_string_ptr("IMPORT"));
long FnvHash::Constants::TABLESAMPLE = FnvHash::fnv1a_64_lower(make_string_ptr("TABLESAMPLE"));
long FnvHash::Constants::BUCKET = FnvHash::fnv1a_64_lower(make_string_ptr("BUCKET"));
long FnvHash::Constants::BUCKETS = FnvHash::fnv1a_64_lower(make_string_ptr("BUCKETS"));
long FnvHash::Constants::UNARCHIVE = FnvHash::fnv1a_64_lower(make_string_ptr("UNARCHIVE"));
long FnvHash::Constants::SEQUENCES = FnvHash::fnv1a_64_lower(make_string_ptr("SEQUENCES"));
long FnvHash::Constants::OUTLINE = FnvHash::fnv1a_64_lower(make_string_ptr("OUTLINE"));
long FnvHash::Constants::ORD = FnvHash::fnv1a_64_lower(make_string_ptr("ORD"));
long FnvHash::Constants::SPACE = FnvHash::fnv1a_64_lower(make_string_ptr("SPACE"));
long FnvHash::Constants::REPEAT = FnvHash::fnv1a_64_lower(make_string_ptr("REPEAT"));
long FnvHash::Constants::SLOW = FnvHash::fnv1a_64_lower(make_string_ptr("SLOW"));
long FnvHash::Constants::PLAN = FnvHash::fnv1a_64_lower(make_string_ptr("PLAN"));
long FnvHash::Constants::PLANCACHE = FnvHash::fnv1a_64_lower(make_string_ptr("PLANCACHE"));
long FnvHash::Constants::RECYCLEBIN = FnvHash::fnv1a_64_lower(make_string_ptr("RECYCLEBIN"));
long FnvHash::Constants::PURGE = FnvHash::fnv1a_64_lower(make_string_ptr("PURGE"));
long FnvHash::Constants::FLASHBACK = FnvHash::fnv1a_64_lower(make_string_ptr("FLASHBACK"));
long FnvHash::Constants::INPUTFORMAT = FnvHash::fnv1a_64_lower(make_string_ptr("INPUTFORMAT"));
long FnvHash::Constants::OUTPUTFORMAT = FnvHash::fnv1a_64_lower(make_string_ptr("OUTPUTFORMAT"));
long FnvHash::Constants::DUMP = FnvHash::fnv1a_64_lower(make_string_ptr("DUMP"));
long FnvHash::Constants::BROADCAST = FnvHash::fnv1a_64_lower(make_string_ptr("BROADCAST"));
long FnvHash::Constants::GROUP = FnvHash::fnv1a_64_lower(make_string_ptr("GROUP"));
long FnvHash::Constants::GROUPING = FnvHash::fnv1a_64_lower(make_string_ptr("GROUPING"));
long FnvHash::Constants::WITH = FnvHash::fnv1a_64_lower(make_string_ptr("WITH"));
long FnvHash::Constants::FROM = FnvHash::fnv1a_64_lower(make_string_ptr("FROM"));
long FnvHash::Constants::WHO = FnvHash::fnv1a_64_lower(make_string_ptr("WHO"));
long FnvHash::Constants::WHOAMI = FnvHash::fnv1a_64_lower(make_string_ptr("WHOAMI"));
long FnvHash::Constants::GRANTS = FnvHash::fnv1a_64_lower(make_string_ptr("GRANTS"));
long FnvHash::Constants::STATISTIC = FnvHash::fnv1a_64_lower(make_string_ptr("STATISTIC"));
long FnvHash::Constants::STATISTIC_LIST = FnvHash::fnv1a_64_lower(make_string_ptr("STATISTIC_LIST"));
long FnvHash::Constants::STATUS = FnvHash::fnv1a_64_lower(make_string_ptr("STATUS"));
long FnvHash::Constants::FULL = FnvHash::fnv1a_64_lower(make_string_ptr("FULL"));
long FnvHash::Constants::STATS = FnvHash::fnv1a_64_lower(make_string_ptr("STATS"));
long FnvHash::Constants::OUTLINES = FnvHash::fnv1a_64_lower(make_string_ptr("OUTLINES"));
long FnvHash::Constants::VERSION = FnvHash::fnv1a_64_lower(make_string_ptr("VERSION"));
long FnvHash::Constants::CONFIG = FnvHash::fnv1a_64_lower(make_string_ptr("CONFIG"));
long FnvHash::Constants::USERS = FnvHash::fnv1a_64_lower(make_string_ptr("USERS"));
long FnvHash::Constants::PHYSICAL_PROCESSLIST = FnvHash::fnv1a_64_lower(make_string_ptr("PHYSICAL_PROCESSLIST"));
long FnvHash::Constants::PHYSICAL = FnvHash::fnv1a_64_lower(make_string_ptr("PHYSICAL"));
long FnvHash::Constants::DISTANCEMEASURE = FnvHash::fnv1a_64_lower(make_string_ptr("DISTANCEMEASURE"));
long FnvHash::Constants::UNIT = FnvHash::fnv1a_64_lower(make_string_ptr("UNIT"));
long FnvHash::Constants::DB = FnvHash::fnv1a_64_lower(make_string_ptr("DB"));
long FnvHash::Constants::STEP = FnvHash::fnv1a_64_lower(make_string_ptr("STEP"));
long FnvHash::Constants::HEX = FnvHash::fnv1a_64_lower(make_string_ptr("HEX"));
long FnvHash::Constants::UNHEX = FnvHash::fnv1a_64_lower(make_string_ptr("UNHEX"));
long FnvHash::Constants::POLICY = FnvHash::fnv1a_64_lower(make_string_ptr("POLICY"));
long FnvHash::Constants::QUERY_TASK = FnvHash::fnv1a_64_lower(make_string_ptr("QUERY_TASK"));
long FnvHash::Constants::UUID = FnvHash::fnv1a_64_lower(make_string_ptr("UUID"));
long FnvHash::Constants::PCTTHRESHOLD = FnvHash::fnv1a_64_lower(make_string_ptr("PCTTHRESHOLD"));
long FnvHash::Constants::UNUSABLE = FnvHash::fnv1a_64_lower(make_string_ptr("UNUSABLE"));
long FnvHash::Constants::FILTER = FnvHash::fnv1a_64_lower(make_string_ptr("FILTER"));
long FnvHash::Constants::BIT_COUNT = FnvHash::fnv1a_64_lower(make_string_ptr("BIT_COUNT"));
long FnvHash::Constants::STDDEV_SAMP = FnvHash::fnv1a_64_lower(make_string_ptr("STDDEV_SAMP"));
long FnvHash::Constants::PERCENT_RANK = FnvHash::fnv1a_64_lower(make_string_ptr("PERCENT_RANK"));
long FnvHash::Constants::DENSE_RANK = FnvHash::fnv1a_64_lower(make_string_ptr("DENSE_RANK"));
long FnvHash::Constants::CUME_DIST = FnvHash::fnv1a_64_lower(make_string_ptr("CUME_DIST"));
long FnvHash::Constants::CARDINALITY = FnvHash::fnv1a_64_lower(make_string_ptr("CARDINALITY"));
long FnvHash::Constants::TRY_CAST = FnvHash::fnv1a_64_lower(make_string_ptr("TRY_CAST"));
long FnvHash::Constants::COVERING = FnvHash::fnv1a_64_lower(make_string_ptr("COVERING"));

long FnvHash::Constants::CHARFILTER = FnvHash::fnv1a_64_lower(make_string_ptr("CHARFILTER"));
long FnvHash::Constants::CHARFILTERS = FnvHash::fnv1a_64_lower(make_string_ptr("CHARFILTERS"));
long FnvHash::Constants::TOKENIZER = FnvHash::fnv1a_64_lower(make_string_ptr("TOKENIZER"));
long FnvHash::Constants::TOKENIZERS = FnvHash::fnv1a_64_lower(make_string_ptr("TOKENIZERS"));
long FnvHash::Constants::TOKENFILTER = FnvHash::fnv1a_64_lower(make_string_ptr("TOKENFILTER"));
long FnvHash::Constants::TOKENFILTERS = FnvHash::fnv1a_64_lower(make_string_ptr("TOKENFILTERS"));
long FnvHash::Constants::ANALYZER = FnvHash::fnv1a_64_lower(make_string_ptr("ANALYZER"));
long FnvHash::Constants::ANALYZERS = FnvHash::fnv1a_64_lower(make_string_ptr("ANALYZERS"));
long FnvHash::Constants::DICTIONARY = FnvHash::fnv1a_64_lower(make_string_ptr("DICTIONARY"));
long FnvHash::Constants::DICTIONARIES = FnvHash::fnv1a_64_lower(make_string_ptr("DICTIONARIES"));
long FnvHash::Constants::QUERY = FnvHash::fnv1a_64_lower(make_string_ptr("QUERY"));
long FnvHash::Constants::META = FnvHash::fnv1a_64_lower(make_string_ptr("META"));
long FnvHash::Constants::TRY = FnvHash::fnv1a_64_lower(make_string_ptr("TRY"));
long FnvHash::Constants::D = FnvHash::fnv1a_64_lower(make_string_ptr("D"));
long FnvHash::Constants::T = FnvHash::fnv1a_64_lower(make_string_ptr("T"));
long FnvHash::Constants::TS = FnvHash::fnv1a_64_lower(make_string_ptr("TS"));
long FnvHash::Constants::FN = FnvHash::fnv1a_64_lower(make_string_ptr("FN"));
long FnvHash::Constants::COPY = FnvHash::fnv1a_64_lower(make_string_ptr("COPY"));
long FnvHash::Constants::CREDENTIALS = FnvHash::fnv1a_64_lower(make_string_ptr("CREDENTIALS"));
long FnvHash::Constants::ACCESS_KEY_ID = FnvHash::fnv1a_64_lower(make_string_ptr("ACCESS_KEY_ID"));
long FnvHash::Constants::ACCESS_KEY_SECRET = FnvHash::fnv1a_64_lower(make_string_ptr("ACCESS_KEY_SECRET"));
long FnvHash::Constants::BERNOULLI = FnvHash::fnv1a_64_lower(make_string_ptr("BERNOULLI"));
long FnvHash::Constants::SYSTEM = FnvHash::fnv1a_64_lower(make_string_ptr("SYSTEM"));
long FnvHash::Constants::SYNC = FnvHash::fnv1a_64_lower(make_string_ptr("SYNC"));
long FnvHash::Constants::INIT = FnvHash::fnv1a_64_lower(make_string_ptr("INIT"));
long FnvHash::Constants::BD = FnvHash::fnv1a_64_lower(make_string_ptr("BD"));
long FnvHash::Constants::FORMAT_DATETIME = FnvHash::fnv1a_64_lower(make_string_ptr("FORMAT_DATETIME"));
long FnvHash::Constants::WITHIN = FnvHash::fnv1a_64_lower(make_string_ptr("WITHIN"));
long FnvHash::Constants::RULE = FnvHash::fnv1a_64_lower(make_string_ptr("RULE"));
long FnvHash::Constants::EXPLAIN = FnvHash::fnv1a_64_lower(make_string_ptr("EXPLAIN"));
long FnvHash::Constants::ISOLATION = FnvHash::fnv1a_64_lower(make_string_ptr("ISOLATION"));
long FnvHash::Constants::READ = FnvHash::fnv1a_64_lower(make_string_ptr("READ"));
long FnvHash::Constants::UNCOMMITTED = FnvHash::fnv1a_64_lower(make_string_ptr("UNCOMMITTED"));
long FnvHash::Constants::COMMITTED = FnvHash::fnv1a_64_lower(make_string_ptr("COMMITTED"));
long FnvHash::Constants::REPEATABLE = FnvHash::fnv1a_64_lower(make_string_ptr("REPEATABLE"));
long FnvHash::Constants::SERIALIZABLE = FnvHash::fnv1a_64_lower(make_string_ptr("SERIALIZABLE"));

long FnvHash::Constants::_LATIN1 = FnvHash::fnv1a_64_lower(make_string_ptr("_LATIN1"));
long FnvHash::Constants::_GBK = FnvHash::fnv1a_64_lower(make_string_ptr("_GBK"));
long FnvHash::Constants::_BIG5 = FnvHash::fnv1a_64_lower(make_string_ptr("_BIG5"));
long FnvHash::Constants::_UTF8 = FnvHash::fnv1a_64_lower(make_string_ptr("_UTF8"));
long FnvHash::Constants::_UTF8MB4 = FnvHash::fnv1a_64_lower(make_string_ptr("_UTF8MB4"));
long FnvHash::Constants::_UTF16 = FnvHash::fnv1a_64_lower(make_string_ptr("_UTF16"));
long FnvHash::Constants::_UTF16LE = FnvHash::fnv1a_64_lower(make_string_ptr("_UTF16LE"));
long FnvHash::Constants::_UTF32 = FnvHash::fnv1a_64_lower(make_string_ptr("_UTF32"));
long FnvHash::Constants::_UCS2 = FnvHash::fnv1a_64_lower(make_string_ptr("_UCS2"));
long FnvHash::Constants::_UJIS = FnvHash::fnv1a_64_lower(make_string_ptr("_UJIS"));
long FnvHash::Constants::X = FnvHash::fnv1a_64_lower(make_string_ptr("X"));
long FnvHash::Constants::TRANSFORM = FnvHash::fnv1a_64_lower(make_string_ptr("TRANSFORM"));
long FnvHash::Constants::NESTED = FnvHash::fnv1a_64_lower(make_string_ptr("NESTED"));
long FnvHash::Constants::RESTART = FnvHash::fnv1a_64_lower(make_string_ptr("RESTART"));

long FnvHash::Constants::ASOF = FnvHash::fnv1a_64_lower(make_string_ptr("ASOF"));
long FnvHash::Constants::JSON_SET = FnvHash::fnv1a_64_lower(make_string_ptr("JSON_SET"));
long FnvHash::Constants::JSONB_SET = FnvHash::fnv1a_64_lower(make_string_ptr("JSONB_SET"));

long FnvHash::Constants::TUNNEL = FnvHash::fnv1a_64_lower(make_string_ptr("TUNNEL"));
long FnvHash::Constants::DOWNLOAD = FnvHash::fnv1a_64_lower(make_string_ptr("DOWNLOAD"));
long FnvHash::Constants::UPLOAD = FnvHash::fnv1a_64_lower(make_string_ptr("UPLOAD"));
long FnvHash::Constants::CLONE = FnvHash::fnv1a_64_lower(make_string_ptr("CLONE"));
long FnvHash::Constants::INSTALL = FnvHash::fnv1a_64_lower(make_string_ptr("INSTALL"));
long FnvHash::Constants::UNLOAD = FnvHash::fnv1a_64_lower(make_string_ptr("UNLOAD"));

long FnvHash::Constants::AGGREGATE = FnvHash::fnv1a_64_lower(make_string_ptr("AGGREGATE"));
long FnvHash::Constants::UNIQUE = FnvHash::fnv1a_64_lower(make_string_ptr("UNIQUE"));
long FnvHash::Constants::PRIMARY = FnvHash::fnv1a_64_lower(make_string_ptr("PRIMARY"));
long FnvHash::Constants::THAN = FnvHash::fnv1a_64_lower(make_string_ptr("THAN"));
long FnvHash::Constants::PROPERTIES = FnvHash::fnv1a_64_lower(make_string_ptr("PROPERTIES"));

// FnvHash::Constants::Constants()
// {
// }
